Watch

Meta Vens 570f369f40 Eureka self cut map r4 (Imagination): Epiphany archived; the harvest, the connector split, nine questions re-checked

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

2026-10-01 23:03:08 +02:00

69 KiB

Raw Blame History

The Mind's own Self: map

Status: map, Imagination (imagination-self), revision 4 of 2026-10-01, session self-2026-10-01b. Campaign eureka-substrate in Eureka's mind (instance eureka). Questions, cut specs, follow-ups and rulings are typed documents there; this page keeps body facts, the harvest, the model page and rationale. Target: docs/eureka-substrate-target.md (133324a7). Rulings this revision rests on: eureka-substrate:ruling:operator-archive-epiphany, :operator-mind-runs-own-self, :operator-mind-mission, :mind-self-burn-rate, :operator-persona-in-mind, :operator-provider-portable-connector, :operator-means-shape-ends, :mind-rules-which-forks, :mind-self-merge-authority, :charters-into-eureka-repo. Superseded and no longer law: :operator-this-is-epiphany, :operator-eureka-adopts-epiphany-body (revision 3's premise). Revision 3 is Huginn e16663f; its probe record (B1-B17, Yggdrasil units, CodexConnector and Ghostlight internals) is cited here by section rather than repeated where nothing changed.

The operator's words, in order. Revision 1:

Eureka thinks in campaigns, right? Well, we already have a Mind campaign, and we're adding evidence to it with every run. The design currently delegates ultimate design authority and work scheduling to the operator, but neither of these is strictly necessary. I want a Self operated by Mind directly.

The Self I talk to here in this one projection of Eureka's mind, and it's how I get it to work on the stuff I care about, like Aetheria. The Mind must operate its own Self instance, with the goal of improving itself.

Revision 2:

I mean impersonation in the sense that there is no operational difference between a work item dispatched on my request versus one dispatched on the Mind's initiative. Yes, that initiative ultimately comes from me, but the Mind's own goal is to become the Perfect Machine. That is the operator directive motivating its every action. How each Mind interprets that mission is up to it.

Not a budget, a burn rate. I want a dial I can crank to determine how active the Mind is, so I can adjust it like I adjust my own usage.

I actually think Persona state should be part of the Mind. Like, we've been talking about a Mind agent as if that has a meaning, but I think the best shape it can have is the agency machinery we already built with voidbot. Then she can speak for herself on Discord, and act by her Self with Eureka.

Revision 3 (the first and third of these are superseded):

I don't think this is voidbot anymore. This is epiphany. What is this if not epiphany?

Epiphany is supposed to be as provider portable as possible, just like Ghostlight, it gets it through a typed connector daemon and I want to continue that tradition.

I think you have the right of it. Eureka should adopt Epiphany as her body.

Look back at the Bifrost charter back when it was called GameCult Labor Platform or GCLP. See the /dossier page on the GameCult site, too. The means shape the ends. We shape the means with the agents we're building, with Epiphany and how we steward it.

Revision 4's law (operator-archive-epiphany):

I think the clean cut is to archive Epiphany. Eureka absorbed her in the womb as fetuses sometimes do.

And a direction on the connector, relayed by the Self this revision, not yet admitted as a ruling (question connector-owner carries it):

Btw CodexConnector should be the codex connector, like it says on the tin. We'll want a Claude compatible connector beside it with shared machinery lifted out, as well as the other options available to Ghostlight.

So: Eureka is the organism and the open project. Her Mind is Huginn (instance eureka), her method is the faculty pipeline (the GameCult/Eureka repo), and her body is whatever of Epiphany still lives, harvested into Eureka's own repos before Epiphany is archived. Nothing stays alive in Epiphany. Where this map says "her", read Eureka.

What stands from revision 1: the Mind's Self is a second agent whose only objective is the Mind, not a rule added to the operator-facing Self. From revision 2: the waking organ is a Persona with pressure, memory and a mouth, who launches her own Eureka Self when the Mind's queue says so; no timer manufactures turns. From revision 3: one typed connector contract in the Ghostlight tradition; Persona state in Huginn as one document; the Discord mouth is the live permit crossing; the GCLP attachments. What revision 4 changes: Epiphany is a harvest source, not a body. Her resident Self and Persona service are not moved as code; what lives of them (the no-replay rule, the crossing and permit modules, the Interpreter's typed output) is rebuilt small inside Huginn's workspace. The epiphany-pipeline leaf and the schema catalogue move into Huginn first, because the live mind is built from them. The model adapter dies; the connector direction replaces it.

Pinned heads for every fact below:

Repo	Ref	Commit
Huginn	`main`, `F:\Projects\Huginn`	`e16663f` (docs only over `a699630b`; crate line numbers hold)
Epiphany	`main`, `F:\Projects\Epiphany` (clean; GitHub `GameCult/Epiphany`)	`4006b14bf29b49410bd18b43acb4d42c3c4e2443` (2026-09-30). Huginn's leaf pin is `ef956865`; `git diff ef956865 HEAD -- epiphany-pipeline schemas` is 58+/227- in `lib.rs` only.
CodexConnector	`main`, `F:\Projects\CodexConnector`	`65192892f0ed829b8a228eabba44a4f3ba0f7268` (frozen since 2026-09-04)
Ghostlight	`main`, `F:\Projects\Ghostlight`	`eeb3a68` (2026-09-23)
Bifrost	`main`, `F:\Projects\Bifrost`; release on Yggdrasil `cb3239aa-f67f5122`	`160fac2` (2026-10-01)
gamecult-ops	`main`	`2aeb7364fffcd404aada28bfd30fb4e5c753cf53`
Eureka skill	`main` (checkout `~/.claude/skills/eureka`)	`b260fbeec6d96ff06882ed9c37d3e1204c424e99`
VoidBot	`main`, `F:\Projects\VoidBot` (clean)	`46d891b` (2026-09-13)
epiphany-graph-rs	`main`, `F:\Projects\epiphany-graph-rs`	`07cd7c1`

Revision 4 ran no host probes; its new facts are repo reads (Epiphany workspace, Huginn workspace, gamecult-ops tree, Bifrost grep, doctrine files) made 2026-10-01 after 20:40 UTC. Yggdrasil facts are revision 3's (B3, B5).

Body facts

B1. The Mind (Huginn on Yggdrasil): unchanged from r3

Instance eureka at rudp://10.77.0.1:17872, 463 documents at as_of 140; thirteen kinds; RulingAuthority { Operator, Standing, Defaulted }; HuginnClient in crates/eureka-state (library plus binary). Huginn's workspace is three crates: huginn-mind, huginn-daemon, eureka-state. huginn-mind/Cargo.toml:22 pins epiphany-pipeline as a git dependency on GameCult/Epiphany at ef956865; epiphany_pipeline is named in 20 Huginn source files (66 uses). CultLib pins: Huginn 8fc74c7 on all three crates; the leaf pins the same 8fc74c7 (Epiphany 73edee5c); Epiphany's root and core pin a0813c6e. So the leaf and Huginn already share one CultLib; only the git edge to Epiphany is in the way.

B2. Claude Code on Starfire: unchanged from r3

Max plan, no API key; claude setup-token is the headless credential; print mode flags including --max-budget-usd; no typed plan usage reachable from Yggdrasil (gap-usage-not-typed). Local scheduled tasks and cloud routines are dead for this purpose.

B3. Yggdrasil: what runs, what dies with Epiphany

From r3 B3, now read as a deletion list rather than a body to rebuild:

Dead Epiphany units: epiphany.service, epiphany-swarm.service, epiphany-heartbeat.service (enabled, dead; the first and third have no source at head), epiphany-model-connector.service (disabled, dead, source extracted into CodexConnector 2026-08-24). Release roots /srv/epiphany/app, /srv/epiphany/source, /srv/epiphany-model-connector. State root /var/lib/gamecult/epiphany (user epiphany, 988; Codex home, workspace, runtime store mind.cc). Config /etc/gamecult/epiphany (Bifrost feedback anchor, empty mcp.toml, root-only credentials/). Idunn targets epiphany and epiphany-model-connector with the Aug 22 recipe at /srv/odin/deploy-manifests/epiphany. Users epiphany, epiphany-model. All of it is the deletion line of mind-self-wake r4; none of it is a harvest item (the runtime store's Persona memory is superseded by B11).
gamecult-ops carries the matching dead tooling: systemd/epiphany.service, systemd/epiphany-swarm.service, runbooks/epiphany-yggdrasil-deploy.md, runbooks/epiphany-starfire-bifrost-crossing.md, and the scripts bootstrap-epiphany-yggdrasil.sh, deploy-epiphany-yggdrasil.sh, check-epiphany-yggdrasil.sh, construct-epiphany-image-yggdrasil.sh, deploy-epiphany-capstone-17*.sh, epiphany-capstone-17-connector-bridge- yggdrasil.sh, provision-epiphany-provider-health-yggdrasil.sh, seal-epiphany-capstone-failure.sh, test-deploy-epiphany-yggdrasil-order.sh, test-epiphany-container-promotion.sh, bifrost-authorize-epiphany-release.sh, configure-voidbot-epiphany-feedback-target-yggdrasil.sh (grep 2026-10-01). inventory.md:581-588, 726-785 describes the Starfire cognition body and the "intended Epiphany deployment body (not installed)". These are deleted or rewritten in the same cut.
What stays: huginn.service, the Bifrost units (bifrost-persona-feedback, bifrost-persona-mouth, the watchdog timer), codex-connector.service as a dead unit until the connector cuts land, the gamecult-model group and its key files, user codex-connector.
Linux users for her: none exist (eureka-mind absent in r3's probe). She needs eureka (body organs: waker, Persona organ, permit issuer; state root /var/lib/gamecult/eureka) and eureka-self (the Self-run unit holding the token); the connector daemons keep their own users.

B4. The forge and the Mind's identity: unchanged except the body's names

Forge user eureka, team minds, key eureka@starfire, no branch protection yet. The body's identifiers r3 kept under "Epiphany names her body" (Linux user epiphany, runtime id epiphany-yggdrasil, Persona agent id epiphany.Persona) lose their reason: the Linux user and runtime id are values she sets herself (eureka, eureka-yggdrasil); the agent id and the crossing's document type ids are Bifrost-side constants (question wire-names, B9). Repos on the forge: Huginn and Eureka are the ones she lands code in; Epiphany never goes to the forge (follow-up body-repos-on-forge narrows to Huginn).

B5. The operator's channel and the Persona's mouth: contract unchanged

The live crossing (r3 B5) is Bifrost's: bifrost-persona-mouth.service admits a signed epiphany.persona_discord_delivery_request.v0 from the configured runtime id, asks the permit issuer at the configured RUDP endpoint for a fresh epiphany.persona_discord_delivery_permit.v0, posts through the bridge CLI as epiphany.Persona, receipts. Bifrost names these in ten files (19 occurrences: tools/persona-discord-delivery-documents.mjs, persona-discord-delivery.mjs, persona-discord-permit.mjs, persona-discord-rudp.mjs, persona-feedback.mjs:90, bifrost-bridge.mjs, docs/bridge.md, three test files). The runtime id, endpoints and anchors are flag values and root files; the type ids and the agent id are code. The Epiphany side of the contract is two modules and one 38-line binary (epiphany-core/src/persona_discord_crossing.rs 535 lines, persona_discord_permit.rs 524, bin/epiphany-persona-discord-permit.rs), depending on ed25519-dalek, cultcache-rs, cultmesh-rs (the brake document) and the core's runtime store for the effect document it signs over. That is the harvest item H5. Inbound feedback (bifrost-persona-feedback outbox deliveries) is unchanged and already Bifrost-native.

B6. Scheduling today, and what the skill derives: unchanged

The recipes derive the queue; the run kind carries claims and ends; the dial is the fourth missing fact. Who reads the queue to wake her: the waker of B10, through HuginnClient.

B7. VoidBot: what `operator-persona-in-mind` now means

With operator-this-is-epiphany superseded, the ruling's words are the nearest law on the Persona's shape: "the agency machinery we already built with voidbot". Revision 2's probe stands: VoidBot's scheduler and initiative engine are paused since 2026-07-16 on the pressure-replay defect; its Interpreter prompt parses SAY / STATE NOTE text blocks by rules; its registry is a JSON file; it is TypeScript over Postgres and a Discord bot. What is borrowed from it is unchanged: the gamecult.persona_state.v0 schema (zod types, projector, persona:migrate-portable as the seed path). What is not borrowed: the scheduler, worker, Postgres queue, bot and providers (the machinery has the defect the run claim removes, B10, and a second Discord identity outside the permit). The ruling's direction is served by shape, not by code: she has a Persona document, pressure, a mouth and a Self she dispatches, which is what VoidBot's machinery was for. Whether that is the reading the operator meant is question persona-turn-runtime's third option.

B8. The `epiphany-pipeline` leaf and the schema catalogue (harvest H1, H2)

epiphany-pipeline (2,836 lines incl. tests; Cargo.toml deps anyhow, chrono, cultcache-rs 8fc74c7, rmp-serde, schemars, serde; dev serde_json) exports the thirteen kinds, PipelineRefusal, PipelineRef, ResolutionOutcome, PIPELINE_SCHEMA_EPOCH = "epiphany.pipeline.epoch.v2", pipeline_key, validate_pipeline_write_envelope. Inside Epiphany nothing consumes it (grep: only its own Cargo.toml and a note). Its only consumer is Huginn. Its test pipeline_published_schemas_match_derivation (lib.rs:2555-2562) reads ../schemas/cultnet relative to the crate, so the fourteen epiphany.pipeline.*.v2.schema.json files and index.json move with it.
schemas/cultnet/ holds 16 schema files plus index.json and a README: the thirteen pipeline kinds, gamecult.persona_state.v0 (the Persona standard; consumers: VoidBot's zod types and projector, the standard doc, Huginn's planned admission validator) and epiphany.work_organ_state.v0 (consumer search across F:\Projects timed out; the only known reader is the skill's faculty-philosophy-cut.md:101 citing it as prose; treat as dead unless Hands finds a reader).
The type ids carry the name: epiphany.pipeline.<kind>.v2, epiphany.pipeline.epoch.v2, and every stored document in mind.redb is keyed and typed by them. The target invariant stored-documents-valid forbids re-keying or re-encoding stored documents; renaming is an epoch bump and a migration (question wire-names). The skill's recipes (references/campaign-state.md:148-304) spell the ids out in every query.
Unlanded Epiphany-repo specs in the mind: cut-mind-authority.r1 and cut-run-kind.r1 (base ef956865, repo GameCult/Epiphany), cut-leaf-key-bound.r1 (base 4006b14b; branch eureka-substrate/leaf-key-bound exists on origin, not merged), cut-merge-epiphany-main.r1 (Cut 0a, landed: codex/eureka-pipeline-state is on main). After H1 every leaf cut has repo GameCult/Huginn.

B9. What else lives in Epiphany, by directory (harvest H3-H9 and the dead)

Line counts are *.rs,*.toml,*.md per directory at head.

Path	Lines	Verdict
`epiphany-pipeline/`, `schemas/cultnet/`	2,836 + schemas	Moves (H1, H2).
`epiphany-core/` (`runtime_spine.rs` 8,728, `current_work.rs` 5,610, `resident_self.rs` 3,044, `reasoning_context.rs` 3,000, `repo_model_documents.rs` 2,292, `repository_body_observer.rs` 2,112, `persona_conversation.rs` 1,818, `atlas/` 10,178, `packaged_release/` 1,172, `surfaces/` 1,034, `memory_graph/` 400, bins 3,394)	54,205	Dies, except the two crossing modules and the permit binary (H5, ~1,100 lines) and the Interpreter's typed output schema in `persona_conversation.rs` (H6, read for shape, not moved). The resident Self (`resident_self.rs` + `bin/epiphany-swarm.rs` 820) is harvested as rules, not code (H4). Its dependency on `ghostlight-persona-projection` (a reverse edge into Ghostlight) dies with it.
`epiphany-openai-runtime/` (`lib.rs` 3,230, `persona_executor.rs` 782, `provider_transport.rs` 296, bins 1,554 + 544)	6,431	Dies. The Persona service's turn is rebuilt as one connector request (H6).
`epiphany-model-adapter/`	1,079	Dies (H7). `cut-epiphany-connector-only.r1` is withdrawn.
`epiphany-tool-adapter/`, `epiphany-tool-mcp-runtime/`	156 + 1,479	Dies. Eureka's tools are Claude Code's.
`epiphany-state-model/src/prompts/epiphany_doctrine.md` (28 lines, no code consumer), `epiphany_state_intro.md`	34	`epiphany_doctrine.md` moves as text (H8); the intro dies.
`epiphany-openai-auth-spine/`, `epiphany-openai-codex-spine/`, `epiphany-self-policy/`, `epiphany-release-construction/`, `apps/`	0 / README only	Dead directories.
`notes/`	37 files	`huginn-organ-cut.md` (Huginn's own cut map, 84 Huginn references), `eureka-pipeline-state-target.md`, `eureka-pipeline-state-cut.md`, `eureka-read-side-cut.md`, `eureka-body-plane-cut.md`, `eureka-query-prior-art.md`, `postmortem-eureka-schema-phase.md` move to Huginn `docs/history/` (H9: they are the mind's own design record). `persona-discord-permit-authority-map.md`, `persona-conversation-authority-map.md` move beside the Persona organ (H5/H6). `faculty-workflow-lessons-2026-09-04.md` moves to the Eureka repo `references/` (the skill already cites it). The rest (anatomy, investor readiness, safety architecture, audits, `archive/`) stay in the archive.
`docs/` (whitepaper `.tex`/`.pdf`, investor brief, positioning, avatar)		Stay in the archive; the positioning prose the operator wants public lives in gamecult-site, not here.
`README.md` ("the beginning of governed human/agent labor", the GameCult bet)		Harvest as prose into the Eureka repo README's opening (H8); the archive README gains the pointer.
`state/` (`map.yaml`, `persona-discord.toml`, `persona-reddit.toml`, msgpack ledgers), `.epiphany-*` sandboxes, `target/`		Die with the checkout; gitignored or local.
`AGENTS.md`, `CLAUDE.md`, `CONTRIBUTING.md`, `CONTRIBUTOR_LICENSE_AGREEMENT.md`, `LICENSE`, `eval-plan.md`		Stay in the archive. The CLA and LICENSE are the operator's to re-apply to Eureka if the open project wants them (H8 asks).

Not of Epiphany, despite the name: epiphany-graph-rs (a standalone Sugiyama/force layout crate, no dependency on Epiphany, MIT/Apache, own GitHub repo) and the EpiphanyAquarium* repos (Aquarium clients; the census gamecult-ops/docs/repo-census-2026-09/repos/EpiphanyAquarium.md already records their deleted EpiphanyAgent and Python scripts). They are outside this harvest; renaming them is cosmetic and nobody's cut here.

Bifrost-side names that survive the archive as wire constants: epiphany.Persona, epiphany.persona_discord_delivery_request.v0, epiphany.persona_discord_delivery_permit.v0, bifrost.persona_discord_delivery_permit_request.v0, source role epiphany-persona-mouth, RUDP connection ids 0xe91f_0002/0003, the Bifrost --epiphany-* flag names. Question wire-names.

B10. The resident Self, read as rules (harvest H4)

What epiphany-swarm and resident_self.rs protect (r3 B11): the brake is read before any consequence; pressure is consumed exactly once, by a single-consumption grant held by one launched turn under a lease; no typed obligation means no wake ("Heartbeat does not ruminate, dream, mutate memory, or manufacture work"); cadence is cooldown, idle and failure backoff. With the run kind in the mind (cut-run-kind: a run claims specs; admission refuses a claim a live run holds, AlreadyClaimed), the grant and the lease are the same fact as the run document: a launch that opens a run with a claim is the grant, and a second waker cycle over the same queue finds the spec claimed and launches nothing. So the resident Self's own state machine (ResidentSelfState, ResidentSelfGrant, ResidentSelfPressure, the prepared-launch and active-turn lease) is not harvested; the mind holds the one fact it existed to hold. What remains to build is a waker that reads the brake and the dial, derives the queue through HuginnClient minus live claims, and starts at most one Self run (question self-waker: one-shot under a timer whose idempotence is the claim, or a resident loop).

B11. Persona state: one document, one writer (harvest H6 shape)

Unchanged in substance from r3 B15, with the second store gone: gamecult.persona_state.v0 in Huginn, opaque, schema-validated at the door, replaced whole under CAS with a receipt (cut-huginn-persona-state.r2). Epiphany's epiphany.mind.persona_memory.v2 documents and the runtime store that holds them die with the checkout and the host state root; nothing of hers was ever written there (the deployed body never ran her). The live writer becomes the Persona organ of H6, through HuginnClient persona_get/persona_put. Question persona-state-owner therefore has one option left and is withdrawn (below).

B12. The connector: what exists, and the operator's new direction

CodexConnector at 65192892 (r3 B14): one crate, feature daemon; lib.rs 1,958 (contract types gamecult.codex.provider_request.v2, transport_invocation.v2, transport_result.v2, transport_receipt.v2, refusals, AES-GCM envelope, framing, CodexConnectorClient), daemon.rs 1,180 (TCP loopback bind, per-caller shared-secret keys, one request per connection, concurrency/payload/output-token limits, 300 s expiry skew, keyed replay replay.cc, restart-era Indeterminate, config gamecult.codex.connector_config.v1), provider_backend.rs 1,463 (CodexProviderBackend: hard-coded OpenAI URLs, auth ApiKey | Chatgpt, a pinned codex app-server child as credential authority), idunn_health.rs 1,396 (Linux-only presence and health participant, capability gamecult.codex.subscription-inference), main.rs 188; the Idunn recipe deployment/idunn/recipe.toml. The request type is rendered as a literal OpenAI Responses body (lib.rs:487-614).

Ghostlight's provider options (r3 B13): the in-process trait InferencePort { prepare, infer, lend_tool_results } (crates/ghostlight/src/controllers.rs:299-311), routed by model-name prefix, longest claim wins (sdk_inference.rs:732-757, controllers.rs:2454-2518); three implementors, every one lowering from CodexProviderRequest: CodexConnectorInferencePort (the connector client), SdkInferencePort (sidecar/claude-sdk/src/main.ts, 517 lines, @anthropic-ai/claude-agent-sdk 0.3.261 over a msgpack pipe; one Claude Code subprocess per query; the request's tools registered as an in-process MCP server; returns usage, total_cost_usd, faults RateLimited | BillingError | MaxBudgetUsd; ambient login or setup-token), LocalInferencePort (OpenAI-compatible loopback POST, no credential, prefix local/). Dungeon no longer opens the connector lane; the live lane is local. Ghostlight's recorded direction (state/map.yaml:438-443): one standardized connector API, the same one Epiphany uses, and a generic OpenAI-compatible connector on it.

The direction, mapped onto that code. "Shared machinery lifted out" is everything in CodexConnector that is not provider_backend.rs: the contract types and refusals, the envelope and framing, the client, the daemon loop (bind, caller keys, limits, replay, config), the Idunn health participant, and the two additions r3 asked for (max_cost_usd on the invocation, cost_usd_estimate on the receipt, the per-caller window spend ledger with refusal Budget). What each connector keeps is its backend: Codex keeps provider_backend.rs as it is; the Claude connector's backend is Ghostlight's SDK sidecar moved in and spawned by that daemon under its own user with the setup-token in a root-0600 EnvironmentFile (a native claude -p backend is a later cut); the OpenAI-compatible connector's backend is LocalInferencePort's POST with a configured base URL and optional key. Callers (Ghostlight, her Persona organ) choose a connector by model prefix in their own config, so Ghostlight's longest-claim routing stays where it is and routes among connector clients instead of in-process ports; no router daemon stands in front of the connectors. Two things the direction does not say, put as sub-questions under connector-owner: where the lifted crate lives (a new repo, or CultLib/packages), and whether the shared request keeps the OpenAI-Responses shape under a provider-neutral name (an epoch bump of the contract ids, connector-contract-untyped) or is redesigned. The ruling operator-provider-portable-connector says "a typed connector daemon" singular; the direction says connectors plural sharing one contract. Read together: one contract, several daemons. That reading is recorded in the question rather than assumed.

B13. The method repo and the body repo

GameCult/Eureka on the forge: LICENSE README.md SKILL.md docs references tools, installed by checkout at ~/.claude/skills/eureka; the charters move in under charters-into-eureka-repo. Its Epiphany references: SKILL.md:3 ("the skill counterpart of Epiphany"), :8-9 ("sits next to Epiphany, the running organism in F:\Projects\Epiphany"), :146 (a call count scar; history), :200 ("Eureka has no Persona"); README.md:63, 86-87, 95 ("Epiphany owns the schemas (epiphany-pipeline) and Huginn owns..."); references/campaign-state.md (the type ids, correct as wire names); references/faculty-philosophy-cut.md and tool-calling-cut.md (dated comparisons; history); references/epiphany-comparison-2026-09-15.md (history). Huginn's workspace is the one Rust workspace that already talks to the mind, has the client crate, the deploy runbook and the release symlink on Yggdrasil. Question body-repo-home asks whether her Rust organs (waker, Persona organ, permit issuer) are crates in Huginn's workspace or a repo of their own; method-repo-home (fold the method into Epiphany) dies with its premise.

B14. Doctrine citations of Epiphany (Life's sweep, nothing edited)

File and lines	Today	After the harvest
`F:\Projects\CLAUDE.md`	No direct citation; points to the Persona standard doc.	Unchanged.
`gamecult-ops/docs/persona-state-standard.md:7-9`	Schema path under `Epiphany\schemas\cultnet`.	Points to the schema's new home (H2): Huginn `schemas/cultnet/gamecult.persona_state.v0.schema.json`.
same `:36-41`	`epiphany-persona-service` runs a separate native Persona Mind; `epiphany-agent-memory-store` removed; `.epiphany-run/` copy.	Deleted. Replaced by one sentence: the Persona organ of Eureka reads and writes the Huginn document (H6).
same `:57-63`	"Huginn ... still unbuilt ... no agent should route Persona-state work to Huginn"; "raise it against VoidBot's implementation and the Epiphany schema".	Reversed by `operator-persona-in-mind`: Huginn is the canonical holder per instance once `huginn-persona-state` lands; VoidBot keeps projection and the migration source for repo Personas; "the Epiphany schema" becomes "the published schema in Huginn". This is `cut-doctrine-persona-in-huginn` r3 (cut 8).
`~/.claude/agents/{eyes,hands,imagination,life,modeling,soul}.md:14`	"Self-improvement law (Epiphany `epiphany_doctrine.md`): ..."	"Self-improvement law (Eureka `doctrine/self-improvement.md`): ..." once H8 lands the file in the Eureka repo; the charters move into the same repo (`charters-into-eureka-repo`), so the citation becomes a relative path.
`life.md:24`, `soul.md:48`	`epiphany_specialists.toml` at `71a5d6fb^`.	Stay as history: a commit-pinned citation into an archived repo still resolves. Add "(archived)" after the repo name.
`hands.md:28`	The 75-binary build-bloat scar.	Stays as history; it is the scar that matters, not the repo.
`~/.claude/doctrine/persona.md:3`	"serves VoidBot and Epiphany Persona work".	"serves VoidBot repo Personas and Eureka's Persona".
`persona.md:13`	Self-improvement law citation.	As the charters' line 14.
`~/.claude/CLAUDE.md:218, 222` (operator-owned; wording proposed only)	"named for Epiphany's continuity organ"; "Epiphany's Life also owns continuity, pressure, and resume-or-regather after re-entry."	Proposed: "named for the continuity organ of Epiphany, Eureka's archived predecessor"; and "That organ also owned continuity, pressure, and resume-or-regather after re-entry; the wider scope arrives when Huginn owns each instance's mind as typed state."
`~/.claude/CLAUDE.md:31`	"not Epiphany lore"	Stays: it names the lore by its historical name, and `colossus.md` keeps the myth.
Eureka `SKILL.md:3, 8-9`	counterpart of / sits next to Epiphany.	"Eureka is the organism: a Mind (Huginn), a faculty method (this skill) and a body (Huginn's organ crates). Epiphany, its predecessor, is archived." By PR (H8).
Eureka `SKILL.md:200`	"Eureka has no Persona: Self is the operator-facing surface".	"The operator channel is this session. Eureka's Persona (the Mind's own mouth on Discord) is not the operator channel; a blocking question still goes to the operator here or by the notifier." By PR, with `skill-mind-self` (cut 7).
Eureka `README.md:63, 86-87, 95`	Links Epiphany as the organism; "Epiphany owns the schemas".	"Huginn owns the schemas (`eureka-pipeline`)"; the comparison reference stays as a dated document.
`~/.claude/doctrine/colossus.md:47, 51`	The Epiphany event as myth.	Stays.
`gamecult-ops/inventory.md`, runbooks, scripts, `systemd/` (B3)	The host body of Epiphany.	Deleted or rewritten in `mind-self-wake` r4 (cut 9).

B15. The governance the Mind's stewardship is an embryo of: unchanged from r3 B17

GCLP decision paths, membership separate from login, work and care work, ledgers and decay, nothing pulling money unsupervised. The four attachments in the rationale stand with "Epiphany" read as Eureka.

The harvest

Order is the order of cuts; a later item may not land before an earlier one it names. "Consumer" is who reads it today; "home" is where it lives after.

#	What	Consumer today	Home after	Decides the home	Order
H1	`epiphany-pipeline` leaf crate (B8)	Huginn (`huginn-mind`, `huginn-daemon`, `eureka-state`)	Huginn `crates/eureka-pipeline` (package and lib renamed; type ids unchanged), copied from Epiphany head `4006b14b` with the `leaf-key-bound` branch's change folded in or re-cut; `huginn-mind` takes a path dependency; the git edge dies	No fork (the only consumer is the home). `wire-names` decides the ids later, not this cut	1
H2	`schemas/cultnet/` (thirteen pipeline schemas, `index.json`, README) and `gamecult.persona_state.v0.schema.json`; `epiphany.work_organ_state.v0` dies unless Hands finds a reader	The leaf's derivation test; VoidBot zod types; the Persona standard doc; Huginn's planned validator	Huginn `schemas/cultnet/` (same cut as H1; the test path becomes `../../schemas/cultnet`); the standard doc re-points (B14)	No fork	1
H3	The unlanded leaf specs `cut-mind-authority.r1`, `cut-run-kind.r1`, `cut-leaf-key-bound.r1`	The mind	Re-admitted as r2 with repo `GameCult/Huginn`, base = the H1 landing commit; same content	No fork	2
H4	The resident Self (`epiphany-swarm`, `resident_self.rs`) as rules (B10)	Nothing live	`crates/eureka-wake` in the body repo: brake and dial read, queue minus live claims through `HuginnClient`, at most one Self-run start; no grant/lease state of its own	`self-waker`, `dial-home`, `body-repo-home`	5
H5	The Persona crossing and permit (`persona_discord_crossing.rs`, `persona_discord_permit.rs`, the permit binary; the two authority-map notes)	Bifrost's mouth (contract)	The Persona organ crate (H6) and its `eureka-persona-permit` binary; the notes under its `docs/`	`body-repo-home`, `wire-names` (what the signed request is called)	6
H6	The Persona turn: the Interpreter's typed output (speech + state notes, `persona_conversation.rs`), the feedback-delivery import, the delivery-request signing	Nothing live	`crates/eureka-persona`: one connector request per turn with an output schema; reads the Persona document and ended runs from Huginn, feedback deliveries from Bifrost's outbox; puts the Persona document under CAS; signs one delivery request	`persona-turn-runtime`, `connector-owner`, `body-repo-home`	6
H7	The model adapter (`epiphany-model-adapter`, `provider_transport.rs`)	Epiphany only	Dies. The connector contract is the lifted crate of B12; `cut-epiphany-connector-only.r1` is withdrawn	`connector-owner` (the lifted crate replaces it)	4
H8	`epiphany_doctrine.md` (text), the README's open-project prose, `faculty-workflow-lessons-2026-09-04.md`, the CLA/LICENSE question	The charters' line 14 cites the doctrine; the skill cites the lessons	Eureka repo: `doctrine/self-improvement.md` (the per-lane law paragraph and the heartbeat and swarm-boundary lines), README opening, `references/`; the charters land in the same repo	`charters-into-eureka-repo` (ruled); whether the CLA applies to Eureka is the operator's, asked in the cut report, not a fork here	8
H9	The mind's design record in `notes/` (`huginn-organ-cut.md` and the six `eureka-*`/postmortem notes)	Readers of Huginn's history	Huginn `docs/history/` verbatim, with a one-line provenance header	No fork	1 (same cut as H1; prose only)
H10	Host state and tooling of the Epiphany body (B3)	Nothing	Deleted: units, release roots, Idunn targets and recipe, users `epiphany` and `epiphany-model`, state and config roots; gamecult-ops scripts, runbooks, units; inventory rewritten	`host-and-units`	9
H11	The GitHub repo		Archived last: README pointer to Eureka and Huginn naming what moved and from which commit; final tag `archive-2026-10`; GitHub archive flag (operator action, read-only)	No fork; the operator flips the flag	11

What dies without moving, said plainly: epiphany-core except H5 (atlas, runtime spine, current-work ingestion, repository body observer, reasoning contexts, repo model documents, coordinator and its results, agent launch, substrate gate, packaged release, memory graph, surfaces, the state and release binaries), epiphany-openai-runtime (the native cognition stack and the Persona service binary), the model adapter, both tool crates, the four empty crates, apps/, the Codex-era prompts, the GUI and dogfood sandboxes, the whitepaper and investor documents (archived, not deleted), the host body.

The model page

One row per persistent kind this design adds or changes. Rows for the thirteen existing kinds are in eureka-substrate-map.md.

Kind	Identity (what names it)	Lifecycle (what happens over time)	Authority (who decides)
`ruling` with `authority: Mind` (`cut-mind-authority` r2, Huginn)	`<campaign>:ruling:<label>`; the variant on the document separates Mind rulings from the operator's.	Created by the Mind's Self when it rules a substrate-internal fork; superseded like any ruling; the operator overturns one with an Operator ruling. Stored rulings decode unchanged.	The Mind's Self admits them; the `run` record is the attribution until `operator-authority-needs-operator-credential` lands.
`run` (instance-rooted; `cut-run-kind` r2, Huginn)	`<instance>:run:<label>`; label `mind-<date>-<n>` for her Self (allocated by the waker), the Self's chosen label for the operator-facing Self. Fields `instance, operated_by: Operator \| Mind, host, started_on, budget_usd, claims, campaigns`.	Opened at launch before any other admission; ended `Recorded { reason }` or `Withdrawn`; a live run older than 24 h is withdrawn by the waker's next cycle. A spec claimed by a live run is not in another run's queue.	The Self that runs it admits it; admission refuses a claim a live run holds (`AlreadyClaimed`). The run is the grant: the waker launches nothing when the queue minus live claims is empty, and the Persona turn reports ended runs.
`gamecult.persona_state.v0` for an instance (Huginn; `cut-huginn-persona-state` r3)	One global document per mind, `personaId` = instance slug; schema vendored by hash from Huginn's own `schemas/cultnet` after H2.	Seeded once from VoidBot's `persona:migrate-portable` output by the operator-facing Self; replaced whole by `PersonaPut { state, expected_updated_at }` under CAS; read by `PersonaGet`.	Huginn admission owns entry. The Persona organ (H6) is the only live writer. Forbidden: a local `.cc` as canonical; any second copy without `provenance.authority: projection`.
The brake and the burn-rate dial (question `dial-home`)	A: one root-owned control store on Yggdrasil, `/etc/gamecult/eureka/control.cc`, documents `eureka.control.brake.v0 { released, set_at, set_by }` and `eureka.control.burn_rate.v0 { heat: 0.05..2, set_at, set_by }`, written by `eureka-control` (a small CLI run as root over ssh), read by the waker and the permit issuer before every consequence. B: instance-rooted `brake` and `burn_rate` documents in Huginn, one in force, admitted under the operator credential.	A: absent brake reads as held; absent heat reads as 1.0. B: superseded by resolution; waits on the credential follow-up.	The operator only; no organ of hers can write the store (filesystem under A, credential under B). Derived: waker cadence (`cooldown / heat`, bounded), run size (`max_cost_usd = base_usd × heat` in every connector invocation and every Self-run `--max-budget-usd`).
The connector's caller spend ledger (lifted crate; `gamecult.model.caller_spend.v1`)	Keyed by caller runtime id and window start; sum of `cost_usd_estimate`, request count, window cap from the caller config.	Rolled per 24 h window; refusal `Budget` at the cap; projected into each daemon's presence health.	Each connector daemon owns its own; the caller config (root) sets the cap. Never the plan's own usage (`gap-usage-not-typed`).
Her identity on each surface	The Mind: instance `eureka`, forge user `eureka`, Discord display name Eureka (question `her-name` dies: there is no other name once the body is not Epiphany). The body: Linux user `eureka`, runtime id `eureka-yggdrasil` (a flag value on Bifrost's unit), Persona agent id and crossing type ids per `wire-names`.	Instance never renamed; runtime id set at rebinding; the display name and avatar are the Bifrost binding's fields.	The operator names her; `wire-names` is a Bifrost cut if it renames.
The Mind's credential (`CLAUDE_CODE_OAUTH_TOKEN`)	Two root-0600 `EnvironmentFile`s on Yggdrasil: the Claude connector daemon's and `eureka-self@.service`'s. Never user `eureka`.	Created with `claude setup-token`; rotated or revoked by the operator.	The operator. Question `host-and-units`.
The Mind's forge key per host	`eureka@<host>` keys on forge user `eureka`.	`provision-forge-minds-eureka`.	gamecult-ops runbook, run as root.
Her units and anchors (`cut-mind-self-wake` r4)	`eureka-wake.timer` + `eureka-wake.service` (or `eureka-wake.service` resident, per `self-waker`), `eureka-persona.service`, `eureka-persona-permit.service`, `eureka-self@.service`, `claude-connector.service`, `codex-connector.service` (existing unit, re-pointed at the split crate); mouth and permit anchors for runtime `eureka-yggdrasil`; the Bifrost mouth unit's three flags.	Hand-installed by gamecult-ops per `reader-deploy-owner` and the Huginn precedent; Idunn targets re-declared later as the deletion line. The Epiphany units, roots, users and targets are deleted first.	gamecult-ops owns the install; the operator creates the token and the anchors (root).

Cells not fillable from the Body: the token's lifetime; the 24 h run bound (a proposal); base_usd; whether the SDK's total_cost_usd tracks the plan's accounting closely enough to be the dial's measure.

The authority map

Owner: Eureka, in three organs with one Mind. Huginn owns what is true (every document, every receipt, every claim). The waker owns when she works: it turns the brake, the dial and the queue minus live claims into at most one Self-run start. The Persona organ owns what she says and her one Persona document (one CAS put per turn, one signed delivery request per turn). Her Self run (a Eureka session under eureka-self@) owns, within the Mind's jurisdiction: which substrate work happens next (the fixed queue order), the dispatch of Imagination, Hands, Soul and Life, Mind-authority rulings on substrate-internal forks, merging her own PRs after a holding Soul verdict, opening campaigns whose repos are Mind repos.
Inputs: her Persona document and the queue and ended runs (Huginn, through HuginnClient); the brake and the dial (the control store); Bifrost Persona-feedback deliveries (the outbox); her checkouts of Huginn, Eureka, gamecult-ops and the connector repos; the verify stopgap. Nothing from Starfire, nothing from the operator's projects, no prose handoff.
Outputs: signed Discord delivery requests through the typed crossing (posted by Bifrost under a permit her issuer grants while the brake is released); one Persona-state put per turn; at most one Self launch per unclaimed queue, which opens a run, admits documents, pushes branches and PRs to the forge, merges; connector invocations carrying max_cost_usd.
Derived state: HANDOFF prose files are display-only and die once run exists; "what is Self working on" is a query over live runs; "how active is the Mind" is the dial; "what did my Self do" is a query over ended runs, projected by her Persona turn in her voice; each connector's spend ledger is a projection of receipts; the resident Self's grant and lease are no longer owners, they are derived from run claims; Epiphany's runtime Mind is dead.
Forbidden writers: she never sets the brake or the dial; never rules a fork outside substrate-internal ones; never edits ~/.claude/; never pushes to GitHub; never runs on Starfire; never writes her Persona state anywhere but Huginn; never holds the Claude token (the Claude connector and the Self-run unit do); never posts to Discord outside the permit crossing. No Epiphany binary runs again. VoidBot's scheduler, worker, registry and heat never decide anything for her. No connector executes a tool call or hosts an agent session. The operator-facing Self never claims a spec a live Mind run holds and never writes a prose handoff in place of a run.
Shared paths: both Selves admit through the same eureka-state tools and admission rules; both open a run first; both read the queue with the same recipes minus live claims; both land code through branch-protected PRs on the forge and the same merge rule; both verify through the stopgap; every model turn of hers and of Ghostlight's goes through the same connector contract (different daemons, one contract); every Discord post of hers goes through the same permit crossing.
Deletion line: before her units run for the first time: Huginn's git edge to Epiphany is gone (H1); the three dead Epiphany units, the model-connector unit, the Idunn epiphany and epiphany-model-connector targets, /srv/epiphany*, /var/lib/gamecult/epiphany, /etc/gamecult/epiphany, users epiphany and epiphany-model are removed from the host; gamecult-ops' Epiphany scripts, runbooks and units are deleted; cut-epiphany-connector-only.r1, cut-epiphany-persona-huginn.r1, cut-epiphany-self-eureka-run.r1, cut-mind-self-wake.r3 are withdrawn (the first dies, the others are re-cut against the body repo); the prose handoff files are retired into runs; the local .cc as canonical Persona store for instance eureka never exists; the two doctrine passages of B14 are rewritten in the cut that lands the reader; Epiphany is archived last.

The nine questions, re-checked

stand: unchanged, a ruling can pick an option as admitted. changes: the options are re-admitted as r2 with the text here. dies: withdrawn, with the reason; a successor question is named where one exists. Every question that survives lists its options so a ruling can pick one (gap-answer-outside-options).

self-run-actuator changes. Option native-coordinator dies with epiphany-mvp-coordinator. Remaining: A actuator-unit: the waker starts eureka-self@<label>.service under user eureka-self (root-0600 EnvironmentFile with the setup-token, the eureka forge key, the Mind's checkouts, the eureka-state MCP config) through one sudoers line, passing --max-budget-usd from the dial; the run opens and ends a run document; the connector is untouched. B connector-session: the Claude connector gains an agent-session operation with Claude Code print mode behind it, so no unit of hers holds the token; the connector becomes an agent host with workspace, git and MCP reach, against its own boundary. Recommendation A: the connector's trustworthiness is that it transports a request and cannot execute a tool call; Claude Code is the Eureka pipeline's one runtime, a fact about the method, not a provider choice.
connector-owner changes (the operator's direction, B12). Option generalize-codex-connector dies: CodexConnector stays the Codex connector. Options for the ruling: A kit-and-connectors-beside: the shared machinery (contract types and refusals, envelope and framing, client, daemon loop with caller keys, limits, replay and config, Idunn health participant, max_cost_usd, cost_usd_estimate, the spend ledger and refusal Budget) is lifted into one crate; codex-connector keeps provider_backend.rs and becomes a thin binary over the kit; a claude-connector binary beside it whose backend is Ghostlight's SDK sidecar spawned under the daemon's user; an openai-compatible-connector binary whose backend is LocalInferencePort's POST; Ghostlight's three in-process ports become three connector clients in its own campaign; her Persona organ configures the Claude connector. B kit-inside-codex-repo: the same split, but the kit is a workspace member of the CodexConnector repo and the other connectors depend on it by git; one repo, the name on the tin wrong for two of its three binaries. C claude-variant-in-her organ: her Persona organ spawns claude -p itself; no daemon change; violates operator-provider-portable-connector (a provider door in her process, the token in her user). Recommendation A. Two sub-forks the direction leaves open, which the ruling should also pick: (i) the kit's home, new repo (name the operator's; the default proposal is GameCult/ModelConnector) or CultLib/packages (recommended against: CultLib holds the CultCache/CultNet/CultMesh runtimes, and a connector kit is a consumer of them, not a runtime); (ii) the contract's shape, keep the OpenAI-Responses request shape that every Ghostlight port already lowers from, renaming the ids gamecult.codex.* to gamecult.model.* in one epoch bump when connector-contract-untyped converts it to CultCache typed documents (recommended), or redesign a provider-neutral request now (a second contract while the first still has three callers). An inconsistency to rule on, not resolve here: operator-provider-portable- connector says "a typed connector daemon", singular; the direction says connectors plural. The map reads it as one contract, several daemons.
persona-state-owner dies. Option epiphany-runtime-store died with the store; a question with one option is not a fork. Withdrawn; the one remaining shape is cut-huginn-persona-state r3's (consumer: the Persona organ) and the doctrine cut.
dial-home changes. Option beside-the-brake loses its store (the brake lived in Epiphany's control store). Remaining: A root-control- store: brake and dial as two documents in one root-owned control store on Yggdrasil (/etc/gamecult/eureka/control.cc), written by an eureka-control CLI as root, read by the waker and the permit issuer before every consequence; she cannot write it by filesystem permission; no new credential mechanism. B huginn-document: instance-rooted brake and burn_rate documents in Huginn admitted under the operator credential; waits on operator-authority-needs-operator-credential, until then anyone with the MCP could admit one. Recommendation A first, B the day the credential lands, with A's documents becoming derived then.
mouth-binding stands with the option text re-homed: A crossing-on-yggdrasil rebinds the live crossing to runtime eureka-yggdrasil (anchors, the permit issuer from H5 bound on 10.77.0.1, the mouth unit's three flags), Aquarium channel kept or one the operator names; B webhook-cli-direct (a second mouth outside the brake); C silent-for-now. Recommendation A.
host-and-units changes. Option interim-units-from-head no longer means Epiphany head: A interim-units: gamecult-ops hand-installs her units from the body repo (eureka-wake, eureka-persona, eureka-persona-permit, eureka-self@, claude-connector; codex- connector re-pointed at the split crate), creates users eureka and eureka-self, deletes the Epiphany host body (H10), re-declares Idunn targets later as the deletion line. B idunn-targets-first: declare Idunn targets for every unit from the start; nothing hand-installed; correct by doctrine, and the Idunn recipe work lands first. C starfire: rejected by the load budget. Recommendation A, the Huginn precedent.
her-name dies. Its fork was Eureka versus the body's name; the body has no other name now. She posts as Eureka; the display name and avatar are set in the mouth rebinding. The surviving fork is the wire names (wire-names, new).
method-repo-home dies. Its options were relative to Epiphany's repo. The successor is body-repo-home (new): where her Rust organs live.
authority-thresholds stands unchanged: binary-plus-visible-class, stakes-scaled-now, binary-unchanged. Recommendation binary-plus-visible-class.

New questions this revision raises (admitted by the Self, each with options):

self-waker (blocks cut 5). A one-shot-under-timer: eureka-wake is a one-shot binary under a systemd timer at a short fixed interval; each run reads the brake, the dial and the queue minus live claims and starts at most one Self run; idempotence is the run claim (AlreadyClaimed), cadence is next_eligible = last run end + cooldown / heat, computed from ended runs, no state file of its own. B resident-loop: a resident daemon porting epiphany-swarm's cycle (grant, lease, backoff) over HuginnClient, holding ResidentSelfState in its own store. C persona-decides: the Persona turn itself decides when to launch her Self (VoidBot's initiative shape); the waker only runs Persona turns. Recommendation A: revision 2 killed the timer because a timer plus pressure manufactured turns; with the claim in the mind that defect is structurally gone, and B keeps 3,800 lines of state machine for a fact the mind already holds. C puts a model call in front of every wake and makes cadence depend on a Persona's judgment, which the dial should own.
persona-turn-runtime (blocks cut 6). A connector-request: the Persona turn is one typed request through the Claude connector with an output schema (speech, state notes), built by eureka-persona from the Persona document, feedback deliveries and ended runs; the connector enforces max_cost_usd. B claude-code-actuation: the Persona turn is a second print-mode session under the Self-run unit shape with a Persona brief; the connector has no consumer in Eureka. C voidbot-machinery: revive VoidBot's scheduler, Interpreter and bot as her Persona, reading Huginn through a TypeScript client (withdrawn follow-up huginn-ts-client returns). Recommendation A: it is what operator-provider-portable- connector asks for, it is the smallest organ (one request, one put, one signed document), and it keeps her speech behind the brake and the dial. B would make the whole organism Claude Code with the connector built for Ghostlight alone; C is the paused machinery with the defect plus a second Discord identity.
body-repo-home (blocks cuts 5, 6, 9). A huginn-workspace: her organ crates (eureka-pipeline, eureka-wake, eureka-persona with the permit binary) are members of Huginn's workspace; one Rust workspace, one CultLib pin, one deploy runbook, one release symlink, one campaign repo; Huginn's README says it is Eureka's Mind and body. B new-body-repo: a new forge repo for the organs, Huginn stays the memory organ alone; two workspaces pinning the leaf by git again. C eureka-repo-workspace: the skill repo gains crates/; every ~/.claude/skills/eureka checkout pulls the Rust body (the objection that killed method-repo-home B). Recommendation A.
wire-names (blocks nothing until a rename is wanted; informs cuts 1, 6, 9). The stored type ids epiphany.pipeline.*.v2 and the epoch, and Bifrost's crossing constants (epiphany.Persona, epiphany.persona_discord_delivery_*, role epiphany-persona-mouth, --epiphany-* flags). A freeze: the names are wire history, kept as they are; the archive README explains them; no epoch bump, no Bifrost change. B rename-at-next-epoch: the pipeline ids become eureka.pipeline.*.v3 in the next breaking leaf change (a migration of mind.redb under mind-survives-upgrade), and the crossing ids become eureka.* in one Bifrost cut with the mouth rebinding. C rename-now: both renames as cuts of this campaign. Recommendation A now, B recorded as the rule for when an epoch bump is paid for by something else; the stored-documents-valid invariant makes C a migration bought for a name.

Rationale

Why a second Self and not a rule (unchanged)

The operator has tried doctrine, a dedicated organ (Life), and considered a scored exam. Each puts a barrier in the path of an agent whose reward is the task in front of it. The only shape that uses the instinct instead of fighting it is an agent whose task is the Mind.

Why the harvest is small and the archive is large

Epiphany at head is 66k lines, of which the live mind uses 2,836 (the leaf) and the design uses about 1,100 more (the crossing and permit) plus the shape of one typed Interpreter output. The resident Self's 3,800 lines exist to hold one fact, "which pressure is consumed by which launched turn", which run claims hold in the mind with admission enforcing them. The Persona service's 7,000 lines build a prompt, call a provider, parse a schema and write memory documents into a private store; with the store gone and the connector owning the call, that is one request builder. The model adapter exists to choose between two providers inside Epiphany; the connector direction gives that choice to a caller config and a daemon per provider. Everything else (atlas, runtime spine, repository observer, coordinator) was the Codex-era cognition body that the Eureka pipeline replaced in September. The code is a liability; the harvest takes the invariants and the two modules whose contract a running Bifrost unit already checks.

Why the leaf moves first, and keeps its ids

Huginn's daemon, mind and client are built from the leaf; code-from-main says the live mind is built from main of both repos. Archiving Epiphany with the git edge in place would build the mind from an archived repo. The move is a path dependency and a renamed package; the type ids stay because every document in mind.redb is typed by them and stored-documents-valid is an invariant of the campaign. A name in a wire id is a scar, not a dependency (wire-names).

Why the waker has no state (question `self-waker`)

Revision 2 killed the timer because VoidBot's timer plus unconsumed pressure manufactured turns, and revision 3 took Epiphany's grant and lease as the cure. The cure is a single fact with one owner: "this pressure is consumed by this turn". The run kind puts that fact in the mind, where admission refuses a second claim. Once the mind holds it, a waker that keeps its own copy is a second owner, and a timer that fires into a mind with no unclaimed work launches nothing. So the waker is stateless and the mind is the grant.

Why the Persona turn is one connector request (question `persona-turn-runtime`)

A Persona turn is a prompt built from typed inputs and a typed output (speech plus state notes): exactly the request-to-receipt shape the connector transports, with output_schema_json already in the contract. Putting it behind the connector keeps her cognition provider-portable (the ruling's tradition), keeps the token out of her user, and keeps her speech behind the brake and the dial through max_cost_usd. Her Self run is different in kind: it is an agentic session with a workspace, which no connector may host.

Why the connectors are several daemons over one kit (question `connector-owner`)

The operator's direction names the shape: CodexConnector is Codex; a Claude connector sits beside it; shared machinery is lifted; Ghostlight's other options become connectors too. The shared machinery is everything that makes a connector trustworthy and the same for every provider (admission, keys, replay, limits, receipts, spend, health); the backend is the only thing that differs. One kit crate, three thin binaries, one contract; each daemon under its own user with its own credential; callers route by model prefix in their own config. No router daemon in front: that would be a fourth authority whose only job is to know what the caller config already says.

Why the brake and the dial share one root-owned store (question `dial-home`)

Revision 3 put the dial beside the brake because Epiphany already had one operator control its organs obeyed. The brake needs a home now as much as the dial does; the same reasoning gives them one root-owned store on the host, read by the two organs that have consequences (the waker and the permit issuer), written only as root. Huginn is the cleaner home for both the day it can tell the operator's admission from hers.

Why Persona state stays in Huginn opaque, validated, receipted (unchanged)

Hand-porting the v0 schema into Rust value types would drift from the published JSON Schema; Huginn validates at the door, checks personaId and the CAS, stores one envelope with a receipt. The schema is now Huginn's own published file (H2), vendored by hash in the validator.

Why her mouth is the typed crossing and not the webhook CLI (unchanged)

The crossing is live, signed on both sides, permit-gated by the brake, receipted. Its Epiphany side is the one piece of Epiphany code worth moving as code (H5), because Bifrost checks its contract today.

Why `Mind` is an authority value and why `run` carries claims (unchanged)

A ruling's authority says whose word it is. Two Selves over one Mind need one new fact, who is working what; the run carries its claims, its end and her Self's results.

The Self's fixed queue order (unchanged)

Derived at every launch, from the mind; the first non-empty step is the run's work, and a run does one step:

A blocking question the operator has answered since the last run: skip.
Findings in force, Blocker or High, on Mind campaigns: Hands, then Soul.
Reports with no verdict on Mind campaigns: Soul.
Specs with no report, not blocked, not claimed by a live run: Hands.
gap-* follow-ups in force with no spec: Imagination maps one cut.
Nothing: the run ends Recorded "idle" with no model call beyond the queries. The waker should not have launched; if it did, that is a finding against its queue derivation.

Means shape ends: the four attachments (ruling `operator-means-shape-ends`)

Unchanged from r3 with "Epiphany" read as Eureka: stakes-scaled authority (question authority-thresholds), contributor credit at the landing record (credit-attaches-at-landing), care work counted through run documents and Life's named mutations (care-work-counted), no permanent aristocrat (mind-standing-decay). The portable Persona document, per-Mind forge accounts and one redb file per instance keep exit alive; the operator's sentence "we shape the means with the agents we're building, with Epiphany and how we steward it" now reads with Eureka as the agent being stewarded, and the archive itself is the first act of that stewardship: a body that stopped making sense is cut, not kept.

Campaign home (proposal; the Self admits campaigns and targets)

Keep eureka-substrate for the mind's own cuts: leaf-into-huginn (H1, H2, H9), mind-authority r2, run-kind r2, huginn-persona-state r3, huginn-mind-self-kinds, doctrine-persona-in-huginn r3. Open a sibling campaign eureka-body (title "Eureka's body: the harvest of Epiphany and the Mind's own Self"), repos GameCult/Huginn, GameCult/Eureka, GameCult/gamecult-ops, GameCult/CodexConnector, GameCult/Epiphany (as harvest source and archive target), GameCult/Bifrost (no code change expected; present so a wire-names rename could be a cut), plus the kit repo once it exists. Its target's invariants: one-contract-many-doors ("every model turn of hers goes through the connector contract; no organ of hers holds a provider credential or URL"), persona-state-one-writer, one-mouth-under-the-brake, token-out-of-her-reach, run-is-the-grant ("no organ of hers holds pressure-consumption state outside the mind's run claims"), nothing-runs-from-epiphany ("no unit, build or dependency of hers resolves into the archived repo"). The three Epiphany-repo specs admitted under eureka-substrate in r3 (epiphany-connector-only, epiphany-persona-huginn, epiphany-self-eureka-run) and mind-self-wake r3 are withdrawn when eureka-body opens; their successors below are admitted there. epiphany-cuts-need-a-campaign closes with the opening.

Proposed target r2 for `eureka-substrate` (the Self admits)

canonical_implementations[0] becomes "Key grammar and document kinds: Huginn crates/eureka-pipeline (Rust), type ids epiphany.pipeline.*.v2 kept as wire names." code-from-main becomes "The Huginn daemon, the eureka-pipeline leaf and the eureka-state client the live mind runs are built from commits on Huginn's main." not_in_scope drops "Persona-state reading in Huginn." and gains "Epiphany's runtime organs: archived; the body campaign eureka-body holds the harvest." canonical_implementations gains "Persona state for an instance: Huginn huginn-mind (opaque, schema-validated), schema Huginn schemas/cultnet/gamecult.persona_state.v0; live writer the Persona organ (eureka-body)." Invariants gain persona-state-one-writer as r3 proposed.

Cut order

Each line is a spec Hands can take with the target shape in this map; the section in brackets is where the shape is.

leaf-into-huginn (Huginn; eureka-substrate; no fork). Copy epiphany-pipeline at Epiphany 4006b14b to crates/eureka-pipeline (package eureka-pipeline, lib eureka_pipeline; a git log provenance line in its Cargo.toml comment), fold in the eureka-substrate/ leaf-key-bound branch or leave leaf-key-bound r2 as cut 2's sibling; move schemas/cultnet/ (pipeline schemas, gamecult.persona_state.v0, index.json, README rewritten for Huginn; work_organ_state dropped unless a reader is found) to Huginn schemas/cultnet/; the derivation test path becomes ../../schemas/cultnet; huginn-mind takes eureka-pipeline = { path = "../eureka-pipeline" }; every use epiphany_pipeline in the 20 files becomes eureka_pipeline; Cargo.lock loses the git source; H9 notes land under docs/history/ with a provenance header. Proof: cargo test -p eureka-pipeline -p huginn-mind -p huginn-daemon -p eureka-state on the stopgap; the live mind reads back after a daemon rebuild (mind-survives-upgrade). [B8, H1, H2, H9]
mind-authority r2, run-kind r2, leaf-key-bound r2 (Huginn; eureka-substrate): the r1 content, repo and base re-pointed. [r3 model page rows; huginn-organ-cut.md once moved]
huginn-persona-state r3 (Huginn): as r2 with the schema vendored from Huginn's own schemas/cultnet and the consumer named as the Persona organ. No fork.
connector-kit (CodexConnector and the kit repo; eureka-body; blocked on connector-owner): lift lib.rs's contract, envelope, framing and client, daemon.rs, idunn_health.rs and main.rs's daemon skeleton into the kit crate with a ProviderBackend trait (execute(invocation) -> result, capability(), health()); add max_cost_usd, cost_usd_estimate, the spend ledger and Budget; codex-connector becomes provider_backend.rs plus a main.rs over the kit, its recipe unchanged; claude-connector is a second binary whose backend spawns Ghostlight's sidecar (copied, not depended on) and maps MaxBudgetUsd to Budget; openai-compatible-connector is a third whose backend is one POST with a base URL. Proof: the Codex daemon's existing tests pass unchanged against the kit; a smoke of each binary refusing an expired invocation and an over-budget one. [B12]
eureka-wake (body repo; blocked on self-waker, dial-home, body-repo-home): the one-shot (or loop) of B10; reads the control store; derives the queue through HuginnClient with the recipes minus live claims; allocates mind-<date>-<n>; starts eureka-self@<label> through the sudoers line with --max-budget-usd; withdraws runs older than 24 h; test: two consecutive wakes over one unclaimed spec launch once (the second sees the claim). Depends on 2.
eureka-persona (body repo; blocked on persona-turn-runtime, connector-owner, body-repo-home, mouth-binding): H5 modules moved with their tests and the permit binary renamed eureka-persona-permit; the turn builder of H6 (inputs: PersonaGet, Bifrost outbox deliveries not yet acknowledged, runs ended since the document's updatedAt; one connector request with the Interpreter's output schema; PersonaPut under CAS; one signed delivery request into the crossing store); mention obligations per epiphany-inbound-mentions (renamed persona-inbound-mentions again). Depends on 3, 4. Test: a turn with the brake held signs nothing and puts nothing; a CAS conflict re-reads once.
skill-mind-self (Eureka; blocked on self-run-actuator): the Self brief her unit runs (provenance line per wake-prompt-provenance, the queue recipe, the coexistence rule), and the SKILL.md:200 rewrite. By PR.
doctrine-repoint (Eureka, gamecult-ops, the charters once in the Eureka repo; absorbs doctrine-persona-in-huginn r3 and the charters cut of charters-into-eureka-repo): every row of B14 except the operator's ~/.claude/CLAUDE.md (wording proposed in the cut report) and the rows marked history; H8's doctrine/self-improvement.md and README opening. Depends on 1 (the schema path) and 3 (the reader). By PR on the forge.
mind-self-wake r4 (gamecult-ops; blocked on host-and-units, mouth-binding, dial-home): H10 deletion first; users eureka, eureka-self; the two token files; the control store and eureka-control; the units of the model page; anchors for eureka-yggdrasil; the Bifrost mouth unit's three flags; the runbook; the inventory rewritten. Depends on 4, 5, 6 by prose.
huginn-mind-self-kinds (Huginn; eureka-substrate): pin bump, aliases, AlreadyClaimed, the live-claim subtraction in the recipes. Depends on 2.
epiphany-archive (Epiphany; eureka-body; last): README replaced by the pointer (what moved, to where, from 4006b14b; what was deleted and why, one line each); tag archive-2026-10; the operator sets the GitHub archive flag. Depends on every cut above having landed, proven by nothing-runs-from-epiphany: no Cargo source, unit, script or runbook on the host or in the Mind's repos resolves into the repo.

Rejected

Keeping Epiphany alive as a dependency source after the archive (code-from-main would build the live mind from an archived repo).
Moving the resident Self's state machine as code: a second owner of the consumption fact the run claim holds (B10).
Moving the Persona service as code: 7,000 lines coupled to a dead runtime store for one request builder's worth of behaviour (B9, H6).
A ClaudeCode provider inside her Persona organ, or claude -p spawned by it: a provider door in her process and the token in her user.
Generalising CodexConnector into the one connector (r3): the operator's direction keeps it Codex.
A router or mux daemon in front of the connectors: a fourth authority for what caller config already says.
Reviving VoidBot's scheduler, worker, Postgres or bot for her: the paused replay defect and a second Discord identity (B7).
A timer with its own pressure state (r2's defect) or a Persona that decides cadence (the dial's job).
Renaming the stored type ids now: a migration bought for a name (wire-names).
Folding the method repo into Huginn, or Rust crates into the skill repo: every skill install would pull a Rust body, every Rust build a skill.
The webhook CLI as her mouth; a DM reader as the review channel; Rust value types for the v0 schema; a claim kind separate from run; running her on Starfire. All as before.

69 KiB Raw Blame History Unescape Escape