exoj

Spawned by the fleet seedbox. The seed below is the charter of record — it is versioned in this repo's first commit and never edited afterward. Every experiment here must carry its decision rules as receipts dated BEFORE the run that produced the numbers.

Category-theoretic investigation of the inverted field

Let Field be the category whose

• objects are relational fields (F = (C, {\gamma_c,\eta_c,\Delta_c,I_c}_{c\in C}))
  (cells on a lattice together with the three amplitudes and identity-fragment sets),

• morphisms (F\to F') are lattice-respecting maps of cells that
  – weakly preserve the amplitudes (soft, convex combination),
  – send identity fragments only by inclusion (never by forced identification),
  – commute with the global conservation inequality
  (\overline{\gamma}+\overline{\eta}\le 1).

Composition is ordinary composition of the underlying cell maps; identities are the identity maps on cells.
This is precisely the category CSPersist of the Hermit-Crab paper, re-indexed from “constrained systems” to “fields”.

An observer (o) is a functor

[ O_o : \mathbf{Field} \to \mathbf{Set} ]

that sends a field to the set of cells it currently attends to, and a deformation to the induced restriction.
Parallel observation is simply a family of such functors ({O_o}_{o\in O}).

A deformation (d) is a natural transformation

[ d : \mathrm{Id}{\mathbf{Field}} \Rightarrow \mathrm{Id}{\mathbf{Field}} ]

whose component at each cell is the soft convex update

[ (\gamma,\eta,\Delta);\mapsto;(1-\alpha)(\gamma,\eta,\Delta)+\alpha(\gamma',\eta',\Delta'). ]

Naturality says that the update is independent of the order in which observers attend; that is exactly the parallel-first axiom.

Fix an observer (o).
The first-person causal sequence (the old mark-tape) is the right Kan extension

[ \mathrm{Ran}_{O_o}(\mathrm{Id}),:,\mathbf{1}\to\mathbf{Field}. ]

Explicitly, it is the limit, over the comma category of cells attended by (o), of the field restricted to those cells, linearised by the temporal order of deformations.

Because a right Kan extension is universal, any other sequential presentation of the same attended region factors uniquely through this one.
Hence every first-person log is a derived object; the field is primary.

(This is the same universal property that the Hermit-Crab paper proves for the nesting topology: the hermit-crab pattern is the left Kan extension that solves the agent-embedding problem. Here the dual statement appears for sequentialisation.)

• The conservation axiom is the statement that the terminal object of Field (the “fully crystallised” field) is a limit cone for the diagram of all finite attended sub-fields.
• The creative-band preference is a weighted colimit: deformations whose (\Delta') lies in ([0.4,0.6]) are the generators that receive maximal weight in the colimit that produces the next field state.

The assignment (c\mapsto I_c) is a discrete fibration

[ I : \mathbf{Field}\to\mathbf{Set}. ]

The “never collapse” rule is exactly the statement that this fibration has no non-trivial descent data; i.e. it is a stack for the trivial topology.
Molting (change of shell) is a cartesian lift in this fibration—the same cartesian-lift language used for identity preservation in the Hermit-Crab paper.

There is an adjunction

[ \mathrm{Project};\dashv;\mathrm{Embed} ]

where

• (\mathrm{Project}) sends a field + observer to its right-Kan-extension sequence,
• (\mathrm{Embed}) sends a sequence back into the free field generated by that sequence.

The unit of the adjunction is “take the sequential log you already have and regard it as a field”; the counit is “project the field you already have down to one observer’s log”.
All of the earlier jmark / tape machinery is the concrete computation of this adjunction.

[ \text{Field};=;\text{primary object of }\mathbf{Field}, \qquad \text{Process};=;\mathrm{Ran}_{O}(\mathrm{Id}), \qquad \text{Conservation + creative band + identity};=;\text{limits / colimits / discrete fibration}. ]

Everything sequential is a Kan extension; everything parallel is native.
That is the precise categorical content of the inversion.

Killer-app: ExoJ — external vectorized scratch-paper.

An agent works outside its own forward pass on a live quilt projection of a parallel relational field. JEV emits soft logical vectorized progressions into that surface. The wave-function stays open (chain-of-probabilities). Observation is an explicit, recorded, local act — not the default. The agent can “show its work” as a dependent projection without ever having collapsed the intermediate possibilities.

1. Field — primary object (parallel relational amplitudes on a hex lattice).
2. Quilt — spatial projection = the visual spreadsheet the agent actually sees and writes on.
3. JEV — inference engine that only ever emits soft deformations (classical / JEPA-style / quantum-inspired / cellular-LLM backends).
4. Observer interface — agent attends, deforms, optionally observes, can request a first-person projection.
5. Audit — every deformation is content-addressed; the field itself is the objective proof object.

• 14 soft deformations across multiple backends.
• Only one explicit observation (local collapse).
• Final state: Σ = 1.0, zone = 1.0, probability still open = 0.91.
• Dependent “show your work” projection available for any auditor.
• State saved as a donnable ExoJ shell.

CoT forces every intermediate into a definite term (checks which slit the particle went through).
ExoJ records chain-of-probabilities; refraction across alternatives remains possible until the agent deliberately observes. Temporal programs can tick on cell-groups independently of the linear algebra. The agent sees the whole reasoning surface synoptically, auditable and self-proving, without having collapsed it.

That is the tool: an external, non-collapsing, spreadsheet-native exo-cortex for any agent that needs to show its work while still thinking in superposition.

Granular POCs → assembled system → dog-fooded.

Live session on ExoJ:

1. Seeded two distant concepts (open).
2. JEV parallel exploration across classical / JEPA / quantum-inspired / cellular-LLM backends — still fully open.
3. Attached temporal programs to cell-groups.
4. Secondary observer refracted on an unobserved branch.
5. One explicit observation (local collapse only) → prob_open 1.0 → 0.92.
6. Continued synthesis on remaining open paths.
7. Emitted dependent “show your work” projections for agent, auditor, secondary.
8. Saved donnable state.
9. Reloaded and verified invariants (conservation, open probability, single observation, 3 observers).

Final state: γ=0.1983 η=0.8017 Σ=1.0 Δ=0.5145 zone=1.0 prob_open=0.9412 deformations=39 observations=1 (pinned to artifact of record: experiments/outputs/e40_scratch.json; earlier numbers in this README narrate earlier runs)

Working parts assembled and used as the real system. ExoJ functions as external vectorized scratch-paper: chain-of-probabilities, non-collapsing until deliberate observation, multi-observer, auditable, reloadable.

Granular PoCs — all PASS

Assembled dog-food — real micro-problem

Problem: find a creative bridge between concept A and B, keep alternatives open, optionally observe one answer.

1. Seeds placed                     Σ=1.0  zone=1.0  prob_open=1.0
2. Parallel JEV exploration         Σ=1.0  zone=1.0  prob_open=1.0
3. Temporal program attached        Σ=1.0  zone=1.0  prob_open=1.0
4. Refractions (wave still open)    Σ=1.0  zone=1.0  prob_open=1.0
5. Explicit observation (one locus) Σ=1.0  zone=1.0  prob_open=0.9
6. Continue on unobserved branches  Σ=1.0  zone=1.0  prob_open=0.9

Auditor projection: 14 deformations, 1 collapse, probability still open 0.9, conservation holds.

All granular parts work in isolation and work together. The system was dog-fooded end-to-end on a live reasoning task without collapsing the intermediate wave-function.

Complete ExoJ code

# ExoJ — High-Level Architecture

## One-sentence
External, non-collapsing, spreadsheet-native reasoning surface (quilt projection of a relational field) that an agent treats as vectorized scratch-paper; JEV is the inference engine that emits logical vectorized progressions into that surface.

## Core inversion
- Primary object = parallel relational field (Field)
- Quilt = spatial projection of the field (the visual spreadsheet)
- Process / CoT = dependent linearisation (right Kan extension) — optional, never forced
- Chain-of-probabilities stays open; observation is an explicit, recorded act

## Layers
1. Field core — cells on hex lattice, amplitudes (γ, η, Δ), conservation + creative-band + distinguishability
2. Quilt projection — origin-centric cells, soft parallel writes, live vector sense, temporal programs
3. JEV — emits soft vectorized progressions (classical / jepa / quantum-inspired / cellular-llm)
4. Observer interface — attend, deform, observe, project
5. Audit — content-addressed deformations; field is the proof object

## Killer property vs chain-of-thought
CoT = successive collapse into definite intermediate terms.
ExoJ = successive soft deformations; refraction remains possible until explicit observation.

#!/usr/bin/env python3
"""
ExoJ core — vectorized scratch-paper
Field is primary. Quilt is the projection. JEV emits soft vectorized progressions.
No forced collapse. Observation is an explicit, recorded act.
"""

from __future__ import annotations
import json, hashlib, time, math, random
from dataclasses import dataclass, field
from typing import Dict, List, Tuple, Optional, Any
from pathlib import Path

def hex_dist(q1, r1, q2, r2):
    return (abs(q1-q2) + abs(q1+r1-q2-r2) + abs(r1-r2)) // 2

@dataclass
class Cell:
    q: int
    r: int
    gamma: float = 0.0
    eta: float = 1.0
    delta: float = 0.5
    strength: float = 0.0
    frags: List[str] = field(default_factory=list)
    programs: List[str] = field(default_factory=list)
    touched: int = 0
    prob_mass: float = 1.0

    def soft_write(self, g, e, d, alpha=0.4):
        self.gamma = (1-alpha)*self.gamma + alpha*g
        self.eta   = (1-alpha)*self.eta   + alpha*e
        self.delta = (1-alpha)*self.delta + alpha*d
        self.strength = max(self.strength, g)
        self.prob_mass = min(1.0, self.prob_mass * 0.98 + 0.02)

    def to_dict(self):
        return {
            "q": self.q, "r": self.r,
            "γ": round(self.gamma,4), "η": round(self.eta,4), "Δ": round(self.delta,4),
            "str": round(self.strength,4), "prob": round(self.prob_mass,4),
            "frags": self.frags[-4:], "programs": self.programs[-3:],
            "touched": self.touched,
        }

class ExoJ:
    def __init__(self, name: str = "exoj", radius: int = 4):
        self.name = name
        self.radius = radius
        self.cells: Dict[Tuple[int,int], Cell] = {}
        for q in range(-radius, radius+1):
            for r in range(-radius, radius+1):
                if hex_dist(q,r,0,0) <= radius:
                    self.cells[(q,r)] = Cell(q,r)
        self.seq = 0
        self.deformations: List[Dict] = []
        self.observations: List[Dict] = []
        self.observers: Dict[str, Dict] = {}

    def _norm(self):
        active = [c for c in self.cells.values() if c.touched > 0]
        if not active: return
        g = sum(c.gamma for c in active)/len(active)
        e = sum(c.eta for c in active)/len(active)
        s = g+e
        if s > 1.001:
            for c in active:
                c.gamma /= s
                c.eta   /= s

    def attend(self, observer: str):
        self.observers[observer] = {"seq": self.seq, "t": time.time()}
        return list(self.observers.keys())

    def jev_emit(self, q: int, r: int, gamma: float, eta: float, delta: float,
                 tag: str = "", program: str = None, backend: str = "classical"):
        """JEV step: soft vectorized progression. Never forces a definite token."""
        key = (q,r) if (q,r) in self.cells else (0,0)
        cell = self.cells[key]
        cell.soft_write(gamma, eta, delta)
        cell.touched = self.seq + 1
        frag = hashlib.sha256(f"{self.name}|{q}|{r}|{self.seq}|{backend}".encode()).hexdigest()[:8]
        if frag not in cell.frags:
            cell.frags.append(frag)
        if program:
            cell.programs.append(program)
        self.seq += 1
        ev = {
            "seq": self.seq, "q": q, "r": r,
            "γ": round(gamma,4), "η": round(eta,4), "Δ": round(delta,4),
            "tag": tag, "backend": backend, "program": program,
            "t": time.time(),
        }
        self.deformations.append(ev)
        self._norm()
        return ev

    def observe(self, q: int, r: int, definite: float):
        """Explicit observation = only act that collapses local prob mass."""
        key = (q,r) if (q,r) in self.cells else (0,0)
        cell = self.cells[key]
        old_prob = cell.prob_mass
        cell.prob_mass = 0.0
        cell.delta = definite
        self.seq += 1
        obs = {
            "seq": self.seq, "q": q, "r": r,
            "definite_Δ": definite, "prev_prob": round(old_prob,4),
            "t": time.time(),
        }
        self.observations.append(obs)
        return obs

    def sense(self) -> Dict:
        active = [c for c in self.cells.values() if c.touched > 0]
        if not active:
            return {"γ":0,"η":1,"Δ":0.5,"Σ":1,"active":0,"zone":0,"prob_open":1.0,"observers":[]}
        g = sum(c.gamma for c in active)/len(active)
        e = sum(c.eta for c in active)/len(active)
        d = sum(c.delta for c in active)/len(active)
        zone = sum(1 for c in active if 0.4 <= c.delta <= 0.6)/len(active)
        prob_open = sum(c.prob_mass for c in active)/len(active)
        return {
            "γ": round(g,4), "η": round(e,4), "Δ": round(d,4), "Σ": round(g+e,4),
            "active": len(active),
            "zone": round(zone,4),
            "prob_open": round(prob_open,4),
            "deformations": len(self.deformations),
            "observations": len(self.observations),
            "observers": list(self.observers.keys()),
        }

    def project(self, observer: str) -> Dict:
        """Dependent first-person slice (‘show your work’)."""
        if observer not in self.observers:
            self.attend(observer)
        return {
            "format": "exoj-projection-v1",
            "field": self.name,
            "observer": observer,
            "sense": self.sense(),
            "recent_deformations": self.deformations[-12:],
            "observations": self.observations[-5:],
            "note": "Dependent linearisation of the parallel field. Wave-function remains open except at recorded observation events.",
        }

    def quilt_snapshot(self) -> List[Dict]:
        return [c.to_dict() for c in self.cells.values() if c.touched > 0]

    def save(self, path: str):
        state = {
            "name": self.name,
            "seq": self.seq,
            "sense": self.sense(),
            "quilt": self.quilt_snapshot(),
            "deformations": self.deformations,
            "observations": self.observations,
            "observers": self.observers,
        }
        Path(path).write_text(json.dumps(state, indent=2))
        return path

#!/usr/bin/env python3
"""ExoJ dog-food — assembled working system on a live task."""

import sys, json, random
sys.path.insert(0, "/home/workdir/artifacts/exoj")
from exoj_core import ExoJ
from pathlib import Path

def dogfood():
    random.seed(7)
    exo = ExoJ("dogfood-session", radius=5)
    exo.attend("agent")
    exo.attend("auditor")
    exo.attend("secondary")

    print("=== ExoJ Dog-food Session ===\n")

    # 1. Seeds
    exo.jev_emit(0, 0, 0.08, 0.92, 0.42, tag="concept-A", backend="classical")
    exo.jev_emit(4, -2, 0.08, 0.92, 0.58, tag="concept-B", backend="classical")
    print("1. Seeds", exo.sense())

    # 2. Parallel JEV exploration
    loci = [(1,0),(2,-1),(3,-1),(2,0),(1,-1),(3,-2),(0,1),(2,1)]
    backends = ["classical","jepa","quantum-inspired","cellular-llm"]
    for i, (q,r) in enumerate(loci):
        d = 0.40 + (i % 5) * 0.04 + random.random()*0.03
        exo.jev_emit(q, r, 0.12+i*0.03, 0.88-i*0.03, d,
                     tag="explore", program=f"path-{i}", backend=backends[i%4])
    print("2. Explore", exo.sense())

    # 3. Temporal programs
    exo.jev_emit(2, -1, 0.2, 0.8, 0.50, tag="program",
                 program="every-tick: re-evaluate zone guard", backend="classical")
    exo.jev_emit(1, 0, 0.22, 0.78, 0.49, tag="program",
                 program="async: cellular-llm group call A→B", backend="cellular-llm")

    # 4. Secondary observer on open branch
    exo.jev_emit(-1, 1, 0.18, 0.82, 0.47, tag="refract", backend="quantum-inspired")
    exo.jev_emit(0, 2, 0.2, 0.8, 0.53, tag="refract", backend="jepa")

    # 5. Explicit observation (one locus only)
    exo.observe(2, -1, 0.51)
    print("5. Observed", exo.sense())

    # 6. Continue on open paths
    exo.jev_emit(1, -1, 0.35, 0.65, 0.50, tag="synthesis", backend="cellular-llm")
    exo.jev_emit(3, -1, 0.38, 0.62, 0.52, tag="synthesis", backend="jepa")
    final = exo.sense()
    print("6. Final", final)

    # 7. Show-your-work projections
    for obs in ["agent", "auditor", "secondary"]:
        p = exo.project(obs)
        print(f"   {obs}: open={p['sense']['prob_open']}")

    # 8. Persist
    path = exo.save("/home/workdir/artifacts/exoj/dogfood_state.json")
    print(f"\nDonnable state → {path}")

    # 9. Verify reload
    state = json.loads(Path(path).read_text())
    assert abs(state["sense"]["Σ"] - 1.0) < 0.02
    assert state["sense"]["prob_open"] > 0.5
    assert state["sense"]["observations"] == 1
    print("Invariants hold after reload.")
    return final

if __name__ == "__main__":
    dogfood()

Paths:

• /home/workdir/artifacts/exoj/exoj_core.py
• /home/workdir/artifacts/exoj/exoj_dogfood.py
• /home/workdir/artifacts/exoj/architecture.md

Run: python3 exoj_dogfood.py

1. Paired arms, identical worlds — arms differ only in the mechanism under test; the truth stream, confounders, and reward streams are shared.
2. Decision rules before the run — the exact verdict rule is written into the receipt chain before the full run executes; no post-hoc verdicts.
3. Counterfactual measurement — effects are measured against the same pool with the mechanism zeroed, never against a different world.
4. Honest negatives — a defense that fails, fails loudly, with the mechanism computed from telemetry, not drafted in advance.
5. Replayable — node smoke.mjs green on every commit; CI runs it.

• Turn the charter's question into one experiment with named arms.
• Receipt the decision rules.
• Run, write outputs/, verify the chain, commit.

The adversarial pair that keeps the field honest, on the dynamic vector table (gan/): Cell 01 (Generator) is the moth — it nudges the lightest row and a hash-chosen subset of its neighbours toward a scaled-down copy of the densest row's direction, inside the amplitude budget, and rescales the touched rows' masses (conserving total mass: SPEC I1). Cell 02 (Validator) is specification-first: it re-derives proximity, conservation and dispersion and answers only COMPILED | INDETERMINATE with named codes — the generator's output never enters the pipeline when compileRefused is true.

Constants are pre-registered, not knobs (provenance: quilt-murmur e40_summary.json): MOTH_PROXIMITY = 0.798 (a2 = 0.798023), MOTH_AMPLITUDE = 0.49 (min = -0.493824 / rho = 0.495421), SENSOR_LAG_MS = 3, DEADLOCK_STEPS = 12. Verdicts fail closed: E_CONSERVATION, E_BOUNDARY, E_HOMOGENISED, E_SXC_SPEC (+ the sxc1 codes below). Deadlock or sensor lag fires the deterministic d20 (gan/die.mjs — same seed ⇒ same roll ⇒ same named drift, every roll receipted); a die-driven drift may cross the proximity boundary but is then scarred, not refused. Scars (gan/scars.mjs) are an append-only sha256 chain that survives any table rewind (I6: scars describe history, not state). State exchange uses sxc1 envelopes (gan/envelope.mjs, I7): fail-closed on E_SXC_FIELD / E_SXC_SEQ / E_SXC_PREV / E_SXC_HASH / E_SXC_SPEC, float-free bodies for JS↔Python hash parity. Pathway: exoj emits → cocapn (Python mirror) verifies → quilt-dba stitches. Demo receipt: node gan/demo.mjs → experiments/outputs/w69_bridge3_demo.json.

Wave-66 decomposed 29 SuperInstance works (plus the external research they leaned on) into elementary parts as spreadsheet logic — 528 parts across five canonical layers (substrate / mechanism / policy / interface / evidence), 401 gates, 127 observed holes — and then let jevs walk the layers: soft deformations for concrete gates, explicit recorded collapse only at holes (the ExoJ law). Six lane agents + a keeper produced the corpus.

atlas.mjs is the exoj of that process: the method as an executable, so the next instance needs zero agents to re-run the wave.

node atlas.mjs verify        # re-verify the bundled artifact of record (6 checks)
node atlas.mjs sweep         # re-run the pre-registered gate sweep (exoj policy=ledger)
node atlas.mjs csv           # emit the spreadsheet logic as CSV (parts/gates/ideas/cells)
node atlas.mjs protocol      # the 7-move runbook: REGISTRY → DECOMPOSE → PREREGISTER
                             #   → SWEEP → READ THE MAP → COMPILE → SEAL
node experiments/e_x8_atlas_gatesweep.mjs   # E-X8: kit replay == artifact of record

E-X8 verdict (committed with this section): the kit's replay lands on the byte-identical chain tip (13463fd0…, 606 links) as the live wave — 29/29 per-work verdict maps agree, gate-kind and layer histograms identical, two kit runs deterministic. Offline, keyless, deterministic, agent-free.

Bundled under atlas-data/: corpus.json, the 29 decomposition files (parts/<family>/<work>.json), gate-map.json + sweep_field.json (the judgment field, dunnable), and the wave's receipt ledgers. The rules are pre-registered in atlas.mjs itself — decision rules before the run, forever.

Route by audience — all seven files live in docs/ and were written against this tree (every command verified by execution during wave-69):

• New agent, zero context → docs/ONBOARDING.md — identity, verified commands, reading order, gotchas, open frontier.
• End user of the capability → docs/USER-GUIDE.md — install, first success, everyday tasks, troubleshooting table, FAQ.
• Developer extending the code → docs/DEVELOPER-GUIDE.md — code layout, core concepts, how to extend (experiment / sweep rule / test / invariant), testing, conventions, editor gotchas.
• Engineer operating/reviewing → docs/ENGINEERING-NOTES.md — architecture diagram, invariants and where they are enforced, failure modes, cost envelope, operations, design decisions.
• Executive deciding investment → docs/CTO-BRIEF.md — value, maturity with evidence, risks/mitigations, cost, strategic options.
• Index of all deeper knowledge → docs/KNOWLEDGE-MAP.md — in-repo clusters, pre-existing docs, fleet relationships, journal Task IDs (24-a, 66-b, 66-g, 66-i, 66-j, 67-c1/p, 68-a), receipts of record, search recipes.
• Pre-existing: docs/COG-THESIS.md (the determinacy / transfer-gap hypothesis), LEGIBILITY.md (external audit layer), ANTI-ENTROPY-LOG.md (fault/fix receipts).