diff --git a/notes/epiphany-current-algorithmic-map.md b/notes/epiphany-current-algorithmic-map.md index 5694316b..333cfc9d 100644 --- a/notes/epiphany-current-algorithmic-map.md +++ b/notes/epiphany-current-algorithmic-map.md @@ -658,6 +658,18 @@ route, not a tool route plus a parallel no-tools opinion. The remaining broad `codex-login` graph is therefore isolated supply-chain liability, not hidden runtime-library anatomy. +The target boundary is the independent daemon mapped in +`notes/standalone-codex-transport-migration.md`. One credential-isolated +Yggdrasil connector already serves Ghostlight over encrypted CultNet, proving +the process seam, but its current single-caller, single-key, fixed-model, +stateless, no-tools contract and Ghostlight-owned deployment are not shared +authority. The v2 daemon independently derives and verifies the exact provider +request, returns a digest-bound transport receipt and typed events, and owns +only Codex credential/transport physiology. Once both consumers pass that +contract, Epiphany deletes its Codex spine, Codex-home/readiness plumbing, and +every compiled Codex dependency; Ghostlight deletes its copied wire law and +connector deployment path. + ## Canonical authority map | Owner | Inputs | Outputs | Invariant | diff --git a/notes/epiphany-fork-implementation-plan.md b/notes/epiphany-fork-implementation-plan.md index ae0df46e..2eb560fc 100644 --- a/notes/epiphany-fork-implementation-plan.md +++ b/notes/epiphany-fork-implementation-plan.md @@ -243,6 +243,18 @@ behavior, not as cleanup chores. A narrower OpenAI auth/refresh boundary must preserve exact provider capability and refresh-token authority; a core split must expose an existing semantic owner rather than invent a package taxonomy. +The provider decision is now a service extraction, specified by +`notes/standalone-codex-transport-migration.md`. Promote the already-proven +Ghostlight connector seam into an independently source-owned and Idunn-managed +Codex transport daemon. Its v2 contract must admit distinct callers, bind exact +native/provider request digests, return typed tool calls and terminal transport +receipts, and preserve one credential-refresh writer. Only after Epiphany and +Ghostlight pass that contract may the old paths be deleted. The completed cut +removes Epiphany's Codex spine and auth/readiness plumbing, Ghostlight's copied +wire types and connector deployment authority, and the stale bridge branch as +a production source. No dual daemon or refresh writer is an acceptable +transition state. + Model Atlas has component proofs but no live inter-swarm collaboration run. Preserve its publication, trust, transport, projection, Soul verification, Self admission, wake, brake, and Eve path until Gate 1 exercises the complete crossing. diff --git a/notes/fresh-workspace-handoff.md b/notes/fresh-workspace-handoff.md index 6a8203dc..e2ea8522 100644 --- a/notes/fresh-workspace-handoff.md +++ b/notes/fresh-workspace-handoff.md @@ -3,8 +3,8 @@ Updated: 2026-08-24 Branch: `codex/epiphany-shakedown-live` Latest committed implementation cut: `a6cf9383` -Current pass: Codex transport quarantined at release entrypoints; Ox17 and -Atlas Gate 1 remain paused +Current pass: standalone Codex transport authority mapped; source extraction +is next; Ox17 and Atlas Gate 1 remain paused ## Orientation @@ -45,6 +45,21 @@ authorize the next capstone or Gate 1. ## What just landed +`notes/standalone-codex-transport-migration.md` is the authority and deletion +map for removing Codex transport entirely from Epiphany's process/build body. +Yggdrasil already proves the underlying process boundary through the +Ghostlight-only `epiphany-model-connector.service`, but that connector is +source-owned by stale branch `codex/epiphany-model-bridge`, deployed in +Ghostlight's Idunn transaction, limited to one caller/key/model, stateless, and +unable to return tool calls. The target is an independent Idunn-managed daemon +with one writable Codex refresh store, distinct authenticated callers, exact +native/provider request-digest receipts, typed tool-call pass-through, bounded +replay/concurrency, and redacted CultMesh health. Consumers keep prompts, +projection, tools, retries, interpretation, decisions, and admission. The hard +deletion line removes Epiphany's Codex spine/dependency/auth-readiness plumbing +and Ghostlight's copied protocol/deployment ownership. No live service, +credential, or deployment authority moved in this mapping pass. + Exact `a6cf9383` quarantines concrete Codex/OpenRouter authentication, credential reading, and network transport at the two release entrypoints that perform inference. `epiphany-openai-runtime` now owns only exact native-request diff --git a/notes/standalone-codex-transport-migration.md b/notes/standalone-codex-transport-migration.md new file mode 100644 index 00000000..484e0d0b --- /dev/null +++ b/notes/standalone-codex-transport-migration.md @@ -0,0 +1,261 @@ +# Standalone Codex Transport Migration + +## Objective + +Move Codex subscription authentication and model transport into one independent +GameCult daemon consumed by Epiphany and Ghostlight. The daemon exists to +protect one credential-refresh writer, one upstream compatibility boundary, +and one independently deployable failure domain. It owns no cognition. + +The target is a typed service boundary, not a native in-process ABI. CultNet +MessagePack over authenticated loopback transport is already proven on +Yggdrasil and keeps callers independent of the daemon's language, build graph, +and release cadence. + +## Current mechanism + +Two mechanisms currently overlap: + +1. Epiphany compiles `epiphany-openai-codex-spine` into its model and Persona + entrypoints. That crate imports vendored `codex-login` and `codex-client`. + Epiphany therefore carries Codex credential paths, readiness checks, CLI + arguments, HTTP transport, and the complete transitive Codex build graph. +2. Yggdrasil already runs `epiphany-model-connector.service` for Ghostlight. + It uses encrypted CultNet/MessagePack on loopback TCP 4103, owns a private + writable Codex home, serializes refresh through one `AuthManager`, bounds + payloads and parallelism, rejects replay/substitution, and advertises a + redacted `model.generate.structured` capability through Odin. + +The second path is source-owned by the stale +`codex/epiphany-model-bridge` branch, admits only +`ghostlight-dungeon-yggdrasil`, and is built/deployed inside Ghostlight's Idunn +transaction. Ghostlight duplicates its wire documents locally. The live proof +is useful; the ownership is not. + +## Authority map + +### Standalone Codex transport daemon + +Owner: + +- Codex-compatible credential loading and persistent refresh rotation; +- required client identity and authorization/account headers; +- exact upstream request transmission and provider response decoding; +- per-caller authentication, admission, payload/concurrency limits, and + transport replay protection; +- typed transport receipts and redacted CultMesh/Odin capability/health. + +Inputs: + +- one authenticated caller identity; +- one exact native request and its deterministically derived provider request; +- provider/model admission requested by the caller; +- an expiry bound and request identity. + +Outputs: + +- ordered typed model events; +- one typed transport receipt binding caller, native-request digest, + provider-request digest, provider/model, response identity, usage, and + terminal transport outcome. + +Derived state: + +- current health, capacity, admitted provider/model capabilities, and caller + pressure are CultMesh/Eve projections; +- the bounded replay cache is transport physiology, not decision history; +- request/provider documents returned in the receipt are evidence of bytes + transported, not daemon-owned decisions. + +Forbidden writers: + +- the daemon cannot author prompts, reasoning projections, tool policy, + decision contexts, structured outcomes, retries between agent passes, Mind + mutations, Ghostlight world mutations, or caller scheduling; +- the daemon cannot execute a returned model tool call; +- no caller may read or write the daemon's Codex credential store; +- no consumer deployment brake may gate daemon startup or same-release + continuity. + +### Epiphany + +Epiphany owns its sealed reasoning basis, exact native request, deterministic +provider lowering, tool loop, terminal context, typed result/failure, Mind +admission, and commit receipt. It stores the exact provider request locally and +accepts a daemon result only when the transport receipt binds its exact digest. +The daemon is evidence-bearing Hands physiology for inference; it is not Mind, +Self, Persona, or Modeling. + +### Ghostlight + +Ghostlight owns lived-stream projection, stage/model policy, schema, timeout, +retry, interpretation, and atomic world mutation. It stores the daemon's exact +transport receipt. It does not share a caller key, request namespace, quota, or +decision state with Epiphany. + +### Idunn + +The daemon is an independent Idunn target with its own immutable package, +deployment brake, lifecycle observation, rollback, and signed health. Neither +the Ghostlight nor Epiphany transaction builds, selects, deploys, or rolls back +the daemon. Consumer units may order softly after it or discover it through +Odin; its absence makes model work unavailable without taking either local +state owner down. + +## Shared paths + +Every Codex-backed request uses one path: + +```text +caller-owned projected state + -> caller-owned exact native request + -> pure deterministic provider lowering + -> authenticated connector invocation + -> daemon validates caller + exact request binding + -> vendored Codex auth/client transport + -> typed provider events + transport receipt + -> caller validates receipt/digests + -> caller-owned interpretation and admission +``` + +Persona, repository workers, Ghostlight fast/capable stages, retry, re-entry, +and tool-followup requests share this transport primitive. They retain their +family-specific state and consequence owners. + +## Protocol cut + +The existing v1 connector proves the transport but is not the shared contract. +The v2 hard cut must provide: + +- distinct authenticated caller keys and keyed caller admission; +- exact caller/runtime and request identity; +- exact native-request and provider-request SHA-256 binding; +- model/tool definitions, prior tool calls, and tool results; +- ordered typed text, tool-call, completion, and failure events; +- one terminal transport receipt with provider response and usage identity; +- byte-identical replay for the same caller/request/digest and refusal for a + conflicting replay; +- bounded per-caller concurrency and total payload/output limits; +- no reasoning-delta publication or transcript-retention dependency; +- provider/model capability discovery without credentials or prompt data; +- explicit refusal documents rather than connection-close ambiguity. + +The caller derives the provider request using the shared pure dialect compiler. +The daemon independently derives it from the native request and refuses a +digest mismatch before network access. This retains one canonical native +request while proving which exact provider request was transmitted. + +## Deletion line + +After both consumers pass v2 acceptance: + +### Epiphany + +- delete the `epiphany-openai-codex-spine` package; +- delete all non-vendor compiled dependencies on `codex-login`, `codex-client`, + and vendored Codex; +- delete direct Codex auth/HTTP/SSE transport construction; +- delete `--codex-home`, Codex-home creation, Codex credential readiness, and + Codex credential systemd inputs from Epiphany runtime physiology; +- move Codex header/auth/SSE verifier ownership into the daemon; +- retain only provider-neutral native requests, pure provider lowering, + OpenRouter's separately owned direct credential path, and the connector + client. + +### Ghostlight + +- delete copied connector envelope/invocation/result/model DTO definitions; +- delete its private connector crypto/framing implementation when the shared + typed client owns that law; +- delete connector build, package, selection, rollback, and witness handling + from the Ghostlight Idunn transaction; +- retain Ghostlight stage projection, model policy, timeout, receipt + validation, and world admission. + +### Infrastructure + +- delete the Epiphany-branded connector service/source identity; +- delete the single `--allowed-caller` and shared `gamecult-model` key model; +- delete Ghostlight's ownership of connector deployment; +- remove the old daemon only after the standalone daemon owns the sole writable + refresh store and both consumers pass exact receipt checks. + +No compatibility reader, dual daemon, dual refresh writer, provider-request +fallback, or prompt-shaped HTTP shim survives cutover. + +## Subtraction budget + +The migration may add one repository, one Cargo package, one daemon binary, +one typed protocol module, and one independent Idunn target. Those surfaces are +earned by credential privilege, refresh serialization, independent lifecycle, +and reuse by two live consumers. + +They must replace: + +- Epiphany's entire embedded Codex transport package and transitive build graph; +- Epiphany's Codex credential/config/readiness plumbing; +- Ghostlight's copied protocol/client definitions; +- the stale connector branch as a production source; +- the connector portion of Ghostlight's deployment transaction; +- duplicated caller-specific keys or refresh stores. + +The migration is a failure if maintained code, executable count, credential +writers, or deployment authorities increase after the old paths are deleted. + +## Build budget + +Before cutover, no local workspace-wide build is authorized. + +- The standalone daemon owns one release binary and its focused library tests. +- Epiphany checks only its connector client, pure runtime library, model binary, + Persona binary, and changed coordinator/readiness owners. +- Ghostlight checks only the shared-client integration and consequential model + stage/world-admission tests. +- Idunn performs each repository's exact full release build on Yggdrasil. +- Compiler output roots are measured and cleaned after each focused local pass. + +The expected Epiphany delta is removal of every Codex crate from `cargo tree` +for all Epiphany production targets. The current release-edge proof's 10.473 +GiB/16,483-file footprint is the pre-cut comparison. + +## Migration order + +1. Create the independent source owner from the proven connector behavior, not + by merging the stale branch into Epiphany. +2. Define and test the v2 typed contract, multi-caller isolation, exact request + binding, tool-call pass-through, refusal, replay, and redacted status. +3. Package the daemon as an independent Idunn target without changing the live + refresh writer. +4. Add Epiphany's v2 client and prove transcript-free decision audit plus tool + continuation through a fake connector. +5. Add Ghostlight's v2 client and remove its copied wire law. +6. Stop the old connector, transfer its auth store once under root custody, + start the standalone release, and prove one refresh writer. +7. Cut consumers over independently and verify exact signed health/transport + receipts. +8. Delete embedded Epiphany Codex transport and Ghostlight-owned connector + deployment in the same accepted release sequence. +9. Delete the stale connector branch only after its useful Git history is + referenced from the new repository. + +## Acceptance + +- Epiphany and Ghostlight issue concurrent requests under distinct caller keys; + neither can replay, decrypt, exhaust, or impersonate the other. +- One process and one writable Codex auth store own refresh rotation. +- Exact native/provider request substitution refuses before network access. +- A connector receipt reconstructs the exact transport basis without a model + transcript. +- Epiphany tool calls return as typed intents and execute only through + Epiphany's governed tool owner. +- Ghostlight retains its exact stage/world admission semantics. +- Daemon restart preserves auth and replay invariants without waking either + consumer's cognition. +- Either consumer may be absent or braked while the daemon and the other + consumer remain healthy. +- No Epiphany production target contains a Codex crate in its normal dependency + graph. +- Ghostlight no longer defines the connector protocol or deploys the daemon. +- Idunn independently proves daemon source, package, runtime, and signed health. +- Model Atlas remains untouched and operationally unaccepted throughout this + migration. diff --git a/state/ledgers.msgpack b/state/ledgers.msgpack index 8668100c..08a53a27 100644 Binary files a/state/ledgers.msgpack and b/state/ledgers.msgpack differ diff --git a/state/map.yaml b/state/map.yaml index 06802241..705036f2 100644 --- a/state/map.yaml +++ b/state/map.yaml @@ -55,6 +55,7 @@ current_status: latest_phase: Fresh-package Ox17 remains paused while source subtraction continues. The live source owns keyed Mind, sealed reasoning projections and exact provider requests, direct Body-to-Modeling work, typed frontier planning, Persona, provider-owned Bifrost feedback, and Odin/Idunn deployment receipts. Provider events and receipts are transient transport values normalized into one native persisted model stream/receipt family. The pure OpenAI runtime library opens exact model execution and admits typed provider events; concrete Codex/OpenRouter auth and network transport exist only in release-entrypoint source. Runtime model bindings are request-to-session/job edges; provider, worker ancestry, and reasoning basis remain on the native model request. Runtime tool bindings are intent-to-session/job edges; model ancestry remains on the exact tool intent. Workers use one governed tool-capable route; no parallel no-tools mode survives. Runtime child documents, Hands consequence receipts, and repository-frontier documents carry only causal identity, lifecycle, strong dependencies, semantic payload, and consequence; CultCache plus the runtime root epoch own internal type/schema identity. Runtime identity and swarm binding retain their explicit epoch fields. Sealed worker contexts retain explicit schema and contract because they are exact model input. Autonomous proposal origin belongs to the Proposal-Modeling request; there is no companion binding document or stored hash echo. The immutable repository-domain receipt carries only the canonical repository name and exact authenticated Body hash; runtime, swarm, workspace, envelope identity/schema, prose, and time remain derived. Operator objective intake carries only thread provenance, the asserted objective, source actor/reference, and submission time; CultCache owns envelope identity/schema and the Mind objective owns active state. Persona-memory v2 owns exact Interpreter effect/context provenance; Persona social mention v2 relies on its queue and turn request for routing; tool-receipt v1 owns exact result JSON or error. Research authenticates the real Substrate Gate grant and tool receipts in place, then writes keyed evidence/observations under one exact `Eyes.frontier_research` Mind commit; no source-lookup document or evidence packet survives. Resident Self state v3 and retention head v1 retain lifecycle counts and the exact deletion chain without a causal clock. Mind/runtime writable epochs are v10/v37. The public CultNet catalog contains only three earned portable boundaries: exact OpenAI-compatible provider request, Persona state, and work-organ state. Old writable stores refuse with no migrator or dual reader. Brokkr owns Unity through Eve/CultMesh; a future Rider daemon owns Rider. No Idunn build, package, deployment, Ox root, or Model Atlas Gate run is authorized. Ox16 remains sealed historical evidence. execution_binding_authority_cut: Exact ce6bff12 reduces model and tool execution bindings to the only facts they own. A model binding maps one native request to its runtime session and job; a tool binding maps one typed intent to its runtime session and job. Provider identity, source worker, reasoning basis, and model-request ancestry are no longer copied into bindings or compared through timestamp-shaped API arguments. Validation, retention, public-source lookup, worker terminality, decision sealing, and tool continuation reload the exact native request or tool intent. Runtime writable state advances to v37. Core, epoch refusal, transcript-free decision audit, OpenAI tool continuation, and the release-owned tool runtime pass. The cut removes 67 net source lines and leaves runtime_spine.rs at 9,300 physical lines with 50 public functions and 25 public structs. Verification generated 12.713 GiB across 19,134 files; Cargo cleanup restored the single 1.78 MiB state inspector. Atlas is untouched; no live inter-swarm collaboration has run. provider_transport_boundary_cut: Exact a6cf9383 moves concrete Codex/OpenRouter authentication, credential reading, and network transport out of epiphany-openai-runtime and into one source module included only by the two release entrypoints that perform inference. The pure runtime library retains exact native-request lowering, model-execution opening, typed event admission, tool intent emission, terminal physiology, and audit persistence without depending on any Codex crate. Provider strict-shape proofs move to the release-owned model binary. Persona keeps its family-owned three-stage executor while its concrete runner moves to the Persona service. The duplicate worker route without governed tools plus its CLI mode, DTOs, and coordinator switch are deleted; all workers use one tool-capable route. The cut removes 176 net source lines and adds no crate, executable, process, schema, or epoch. The runtime-library consequence test falls from 12.713 GiB/19,134 files to 1.869 GiB/2,942 files; the release-edge test still reaches 10.473 GiB/16,483 files through codex-login. All focused checks pass, then cleanup restores the exact 1,776,640-byte state inspector. Atlas is untouched and no collaboration acceptance is claimed. + standalone_codex_transport_target: The proven Yggdrasil Ghostlight connector is the seed for an independent Codex transport daemon, not an Epiphany organ. It will own the sole writable Codex credential/refresh store, required client identity, authenticated multi-caller transport, exact request-digest receipts, bounded replay/concurrency, and redacted CultMesh health. Epiphany and Ghostlight retain prompts, projections, tools, retries, decisions, and admission. The current connector is not the target contract: it is Epiphany-branded, source-owned by stale branch codex/epiphany-model-bridge, deployed inside Ghostlight's Idunn transaction, single-caller/single-key, fixed-model, stateless, and tool-forbidding. notes/standalone-codex-transport-migration.md owns the hard authority map, deletion line, build budget, migration order, and acceptance. No live service, credential, or deployment authority has moved yet. fixed_routing_and_retention_cargo_cut: Exact ffd91c20 deletes EyesEvidencePacket.source_role_id, PersonaSocialMention.target_agent_id, and ResidentSelfRetentionHead.retained_at_millis. Each producer supplied one fixed or non-causal value and no consumer read it; the request/context, Persona queue plus turn request, and retention chain remain the real owners. Eyes packet v2, Persona mention v2, Resident Self state v3/retention head v1, and runtime v27 form a hard cut. Core and the three consuming release entrypoints compile; consequential Persona, Research, and epoch-refusal proofs pass. The maintained source delta is 6 net deletions. Atlas is untouched; no live inter-swarm collaboration has run. provider_stream_authority_cut: Exact fe118e13 makes OpenAI/OpenRouter events and receipts transient transport values. The runtime immediately normalizes them into the single persisted native model event/receipt family used by tool continuation, assistant reconstruction, terminal validation, and bounded retention. Duplicate provider writes, registrations, archive requirements, schema IDs, two public schemas/index rows, and the include-only model-runtime shell are gone; the exact provider request remains durable. Runtime advances to v28 and the catalog drops to 18 schemas. The cut removes 270 net maintained lines. Adapter 1/1, provider spine 14/14, reasoning context 8/8, runtime 23/23, model entrypoint 11/11, swarm 4/4, epoch refusal 1/1, and release construction 15/15 pass. Atlas is untouched; live inter-swarm collaboration remains unproven. cultnet_catalog_authority_cut: Exact dbed11b3 and 8bb0719b delete the hand-maintained JSON shadow registry. The nonexistent runtime-event contract and obsolete public archived-session tombstone schema disappear first. Runtime-local identity, session, job, binding, coordinator, native model/tool, and state-ledger schemas then disappear because no live CultNet provider carries them and several contradicted their Rust owners. Typed CultCache registration and owner-projected CultMesh state remain authoritative. The catalog has exactly three earned boundaries: the exact OpenAI-compatible provider request, gamecult.persona_state.v0, and epiphany.work_organ_state.v0. Parse/path/unindexed/forbidden-contract checks pass at 3/3/0/0/0. The cuts remove 850 net maintained lines. Atlas is untouched; live inter-swarm collaboration remains unproven. @@ -154,7 +155,7 @@ current_status: yggdrasil_epiphany_service_contract: idunn_source_change_owner_eve_and_local_typed_operator_surfaces_no_discord_control_plane resident_physiology: historical_c011_exact_465af24d_zero_zombie_proof_accepted_current_containers_exited_255 unresolved_authority: `runtime_spine.rs` remains the largest central liability at 9,300 physical lines, 50 public functions, and 25 public structs; it still mixes immutable identity, sessions/jobs, process claims, model/tool execution binding, family request admission, consequence receipts, retention, and narrow identity/schema reads. Sessions and jobs carry only lifecycle identity/status; terminal result documents own summaries and artifacts. Generic session/job creation is gone; real family launch, model execution, and coordinator owners create runtime physiology. All persisted family launch-binding documents, the standalone verdict-driven Modeling writer, coordinator artifact/status cargo, uninhabited aggregate state-model DTO families, public registered-type catalog, duplicate Eyes acceptance documents, test-only arbitrary runtime writers, and duplicate Persona delivery evidence are gone; immutable worker launches plus typed family requests and atomic admission receipts own launch ancestry and downstream work creation. The release-edge Codex provider still pulls a broad codex-login graph that includes configuration, app-server protocol, telemetry, Starlark, image codecs, and clipboard support; the pure runtime no longer pays that cost. Continue splitting only by deleting callerless or duplicate authority and auditing tests against consequential behavior; do not create family frameworks or adapters. The current gamecult-ops Epiphany unit has retired agent-store and daemon-id argv that its owning lane must fix before deployment. Bifrost's Discord delivery path is a real consumer of Epiphany's short-lived request-bound permit signature, so the distinct permit identity/process remains an earned privilege boundary; current Ygg deployment doctrine still points that crossing at the old Starfire endpoint and installs no issuer unit, which the Idunn lane must repair before Persona consequence readiness. Historical c011 and partial Gate roots stay untouched/read-only. - next_action: Continue the source-shape and test-liability audit after exact a6cf9383. First compare two remaining liabilities by owned behavior: the release-edge codex-login dependency fan-out and epiphany-core's 1.869 GiB cost under one pure runtime consequence test. Narrow or replace the Codex authentication/refresh boundary only if exact provider capability and refresh-token authority remain sound; split core only where a smaller semantic owner already exists. Preserve exact identity, decision audit, conflict/replay, retry ancestry, retention fences, terminal Self provenance, typed frontier planning, Persona consequences, exact native/provider requests, governed tool receipts, and the complete unrun Model Atlas vertical slice. Component tests are not collaboration acceptance. Do not run a local full-workspace compile, package, deployment, Ox root, or Model Atlas Gate run. + next_action: Begin the standalone Codex transport migration from notes/standalone-codex-transport-migration.md. Create the independent source owner from the proven connector behavior without merging the stale bridge branch into Epiphany; prove v2 multi-caller identity, exact native/provider request digest binding, tool-call pass-through, refusal/replay, and redacted status before any consumer or live credential cutover. The accepted deletion line removes Epiphany's embedded Codex spine/build graph/auth plumbing and Ghostlight's copied wire/deployment authority. Preserve one refresh writer, exact decision audit, provider capability, consumer-owned prompts/tools/admission, and the complete unrun Model Atlas vertical slice. Do not run a local full-workspace compile, package, live deployment, credential transfer, Ox root, or Model Atlas Gate run. runtime_spine_surface_cut: `runtime_spine.rs` owns immutable runtime identity, exact sessions/jobs and process claims, model/tool execution bindings, family admission, consequence receipts, retention, and identity-resurrection fences. Provider requests remain exact durable audit input; provider events/receipts normalize into one native persisted stream/receipt family. Session/job documents carry lifecycle identity and status; terminal job results carry summaries, evidence, artifacts, and decision-context identity. Completed model-session retention writes one private resurrection tombstone; archived worker retention keeps exact request/terminal identity, deletion digest, decision context, structured result, and terminal job records. Mind/runtime writable epochs are v10/v37. Runtime identity and swarm binding retain explicit epoch fields; their child physiology, Hands consequence, and repository-frontier documents rely on CultCache type/schema identity rather than carrying fixed duplicate metadata. Sealed worker contexts keep exact model-input schema and contract. Autonomous proposal promotion commits one proposal/request pair; the request owns its exact origin identities. Research coverage derives from the exact structured result and `Eyes.frontier_research` commit receipt, not a companion packet. Persona delivery consequence identity belongs to the social terminal while Bifrost retains the signed crossing request/receipt. Family launch CAS, model execution, and coordinator opening are the only session/job creation owners. The spine is 9,300 physical lines with 50 public functions and 25 public structs. Continue subtraction by tracing each public surface and verifier to a live consumer and consequential invariant; do not recreate deleted authority through registries, adapters, compatibility readers, or summary DTOs.