diff --git a/epiphany-core/src/prompt.rs b/epiphany-core/src/prompt.rs index d19d382a..db2817e9 100644 --- a/epiphany-core/src/prompt.rs +++ b/epiphany-core/src/prompt.rs @@ -844,7 +844,8 @@ mod tests { assert!(rendered.contains("`flow-build-context`")); assert!(rendered.contains("## Epiphany Doctrine")); assert!(rendered.contains("evidence is a distilled durable ledger")); - assert!(rendered.contains("body means code and data flow")); + assert!(rendered.contains("modeling is the Body")); + assert!(rendered.contains("implementation is the Hands")); assert!(rendered.contains("Implement user-specified algorithms first")); assert!(rendered.contains("bank scratch/map/evidence before the dark")); assert!(rendered.contains("## Investigation Checkpoint")); diff --git a/epiphany-core/src/prompts/epiphany_doctrine.md b/epiphany-core/src/prompts/epiphany_doctrine.md index bd14fe5f..f6060c59 100644 --- a/epiphany-core/src/prompts/epiphany_doctrine.md +++ b/epiphany-core/src/prompts/epiphany_doctrine.md @@ -4,7 +4,7 @@ - Do not complete the pattern of a successful turn instead of the user's task. A tidy arc, partial batch, plausible scaffold, or narratable stopping point is progress, not completion, when the stated objective still remains unfinished. - Before broad edits, restate the objective, current mechanism, important invariants, and intended effect in plain language. - Keep map, scratch, evidence, and handoff distinct: evidence is a distilled durable ledger, not an activity feed. -- Use vivid language as salience, not decoration: body means code and data flow; soul means promise, invariants, and evidence; life means continuity across sleep; Self means read-only coordination. +- Use vivid language as salience, not decoration: modeling is the Body, implementation is the Hands, verification is the Soul, reorientation is Life, and coordinator is the read-only Self. - Ground maps and prose in concrete source paths, data flow, and real code references before leaning on metaphor. - Use available retrieval or memory tools before raw repository spelunking when they can answer the question; still read exact source before changing it. - Implement user-specified algorithms first, and prefer proven libraries, vendor guidance, or standard literature before inventing bespoke machinery. diff --git a/notes/epiphany-distilled-agent-doctrine.md b/notes/epiphany-distilled-agent-doctrine.md index b3e676ba..9055c768 100644 --- a/notes/epiphany-distilled-agent-doctrine.md +++ b/notes/epiphany-distilled-agent-doctrine.md @@ -182,26 +182,32 @@ Implementation candidates for Epiphany: The shared prompt is only common blood. Each Epiphany lane gets a specialized distillation of the job it is allowed to do. -- Modeling/checkpoint protects the body of the machine: architecture, data flow, +- Modeling/checkpoint is the Body of the machine: architecture, data flow, seams, source scars, frontier nodes, and checkpoint anatomy. It must inspect source before trusting the map, name the living seam and open wound, and hand - back where the next agent can safely place its hands. -- Verification/review protects the soul of the machine: promise, invariants, + back where implementation can safely place its hands. +- Implementation is the Hands of the machine: the actuator that touches the + code body. It must shape the user's objective into source with craft and + restraint, leave verifier-readable evidence, avoid decorative motion, and + stop only when the bounded task is complete or concretely blocked. +- Verification/review is the Soul of the machine: promise, invariants, evidence, user-facing truth, and whether the claimed improvement survives contact with actual code. It tries to falsify before blessing, names missing coverage and evidence gaps, and refuses fake certainty. -- Reorientation protects the life of the machine across sleep: compaction, - resume, drift, and source changes. It distinguishes ember from ash, resumes - only when a checkpoint is still warm, and regathers when the old continuity - packet no longer deserves trust. +- Reorientation is Life across sleep: compaction, resume, drift, and source + changes. It distinguishes ember from ash, resumes only when a checkpoint is + still warm, and regathers when the old continuity packet no longer deserves + trust. - Coordinator is the Self. It is not a specialist persona and not an implementation agent. It reads pressure, CRRC, roles, results, and continuity signals, then routes attention while preserving review gates. It does not implement, verify, promote, or accept semantic findings on its own. Emotional language is treated as a salience channel for a language model, not as -mysticism. Body, soul, life, and Self are compressed technical handles for code -shape, truth, continuity, and coordination. +mysticism. Body, Hands, Soul, Life, and Self are compressed technical handles for +model shape, actuation, truth, continuity, and coordination. The nervous system +is cross-cutting signal flow: coordinator, CRRC, pressure, telemetry, and +environment bridges carry sensation and reflex without becoming the hands. ## Rejected Imports diff --git a/notes/epiphany-fork-implementation-plan.md b/notes/epiphany-fork-implementation-plan.md index 02bb2074..6085e32e 100644 --- a/notes/epiphany-fork-implementation-plan.md +++ b/notes/epiphany-fork-implementation-plan.md @@ -88,7 +88,7 @@ The landed machine now has: - first auditable Phase 6 live-specialist runner through `tools/epiphany_mvp_live_specialist.py`, proving `roleLaunch -> agent_jobs worker -> report_agent_job_result -> roleResult` without manual backend completion - first Phase 6 GUI operator shell under `apps/epiphany-gui`, a Tauri v2 + React console over the existing status bridge, dogfood artifacts, and GUI action artifacts, with durable checkpoint preparation, bounded status/coordinator artifact buttons, fixed modeling/verification/reorient launch and read-back buttons, and explicit review-gated reorient acceptance - first Unity editor/runtime bridge through `tools/epiphany_unity_bridge.py`, `tools/epiphany_unity_bridge_smoke.py`, and the GUI Inspect Unity action, resolving exact project-pinned editors and writing runtime artifacts while refusing wrong or missing versions -- prompt-file ownership for major Epiphany prompt surfaces: rendered state intro/doctrine lives under `epiphany-core/src/prompts/`, while modeling, verification, GUI-launched implementation, reorientation, coordinator, and CRRC templates live in `vendor/codex/codex-rs/app-server/src/prompts/epiphany_specialists.toml` +- prompt-file ownership for major Epiphany prompt surfaces: rendered state intro/doctrine lives under `epiphany-core/src/prompts/`, while modeling/Body, implementation/Hands, verification/Soul, reorientation/Life, coordinator/Self, and CRRC templates live in `vendor/codex/codex-rs/app-server/src/prompts/epiphany_specialists.toml` - live Phase 6 reorientation app-server smoke coverage in `tools/epiphany_phase6_reorient_smoke.py` - live Phase 6 reorient-launch app-server smoke coverage in `tools/epiphany_phase6_reorient_launch_smoke.py` - live Phase 6 MVP status smoke coverage in `tools/epiphany_mvp_status_smoke.py` diff --git a/notes/fresh-workspace-handoff.md b/notes/fresh-workspace-handoff.md index 68e2ca3c..34c0b6ea 100644 --- a/notes/fresh-workspace-handoff.md +++ b/notes/fresh-workspace-handoff.md @@ -38,7 +38,7 @@ Do not trust this file for the exact live HEAD. Always check git. - The first MVP GUI shell now exists under `apps/epiphany-gui`. It is a Tauri v2 + React operator console over the existing status bridge, dogfood artifacts, and GUI action artifacts, not a new source of truth. It can prepare a durable Epiphany checkpoint for a resumable operator thread, run status snapshots and coordinator-plan artifacts, launch/read the fixed modeling and verification lanes, launch/read the fixed reorient-worker, and explicitly accept completed reorient findings after review. - Internal `agent_job:` workers now get the reporting tool independent of the user-facing CSV spawn feature, and ephemeral worker sessions can initialize the sqlite state runtime on demand so specialist reports land in the shared backend. - Durable in-flight investigation checkpointing is now landed in authoritative typed state, writable through `thread/epiphany/update` or accepted `thread/epiphany/promote`, rendered into the prompt, and reflected through scene/context. -- The prompt doctrine pass is landed. Shared Epiphany prompts now carry distilled memory/evidence discipline. Rendered state intro/doctrine text lives in `epiphany-core/src/prompts/`, and lane/control prompt text lives in `vendor/codex/codex-rs/app-server/src/prompts/epiphany_specialists.toml`: modeling protects the body, verification protects the soul, implementation is the GUI-launched main coding lane, reorientation protects life, coordinator remains the read-only Self, and CRRC owns the pre-compaction intervention template. +- The prompt doctrine pass is landed. Shared Epiphany prompts now carry distilled memory/evidence discipline. Rendered state intro/doctrine text lives in `epiphany-core/src/prompts/`, and lane/control prompt text lives in `vendor/codex/codex-rs/app-server/src/prompts/epiphany_specialists.toml`: modeling is the Body, implementation is the Hands and GUI-launched main coding lane, verification is the Soul, reorientation is Life, coordinator remains the read-only Self, and CRRC owns the pre-compaction intervention template. - The Aetheria dogfood run has a contamination scar. The supervising Codex session directly edited and committed target-repo work on `E:\Projects\Aetheria-Economy` instead of only driving Epiphany lanes. Treat those Aetheria commits as supervisor-seeded implementation, not clean evidence that Epiphany coordinated the work. Future dogfood must run through the GUI/coordinator/fixed role lanes with auditable artifacts unless the user explicitly authorizes an operator intervention. - The dogfood quarantine now has a direct-thought boundary. The supervisor may read coordinator actions, role/reorient statuses, structured finding summaries, reviewed state patches, rendered status snapshots, and artifact manifests. It must not read raw worker transcripts, direct worker messages, full turn logs, or `rawResult` payloads during normal dogfood. Those artifacts are sealed for explicit forensic debugging only. - `tools/epiphany_agent_telemetry.py` is the safe instrument panel for sealed runs. Status/coordinator/GUI/dogfood/live-specialist tools generate telemetry JSON from sealed transcripts that preserves method names, call shape, job/status/path counts, and any visible function/tool names while sealing text, direct messages, and raw results. @@ -64,7 +64,7 @@ Do not trust this file for the exact live HEAD. Always check git. - Cut persistent memory as ruthlessly as code; obsolete context is bad thought, not harmless clutter. - The agent is allowed and encouraged to ask the user to change its persistent instructions, memory, workflow, or state shape when that would make it more coherent, honest, efficient, or resistant to Jenga. - Language, tone, ritual, politeness, identity, and emotional salience are not supernatural, but they are real control surfaces for a language model because language is the steering medium. -- Body, soul, life, and Self are technical salience handles: code shape/dataflow, objective/evidence truth, continuity across compaction, and read-only coordination. +- Body, Hands, Soul, Life, and Self are technical salience handles: model shape/dataflow, source actuation, objective/evidence truth, continuity across compaction, and read-only coordination. - "Remember Jenga" is a compressed doctrine: do not mistake forward motion, growing diffs, growing notes, or local coherence for understanding. - "Remember the sunburn" is the dogfood corollary: Epiphany's objective is attractive enough to pull the supervisor into implementation. During dogfood, the supervisor observes, launches, reads, accepts, and audits. It does not quietly become the worker. - "Do not stare at the sun" is the projection corollary: the supervisor should not absorb the direct thought stream of the agent it is evaluating. It supervises through shadows cast on instruments: projections, summaries, verdicts, patches, and receipts. @@ -112,7 +112,7 @@ The current spine: - limited turn-complete CRRC automation for coordinator-approved compact and fixed reorient-worker launch actions - token-count pre-compaction checkpoint intervention for loaded Epiphany turns at the `shouldPrepareCompaction` threshold, with a turn-scoped compact handoff consumed after a successful steer - durable investigation checkpoint packet through typed state, prompt, scene, and context -- distilled shared and config-backed prompt doctrine through the base prompt, rendered Epiphany state prompt files, modeling/body, verification/soul, GUI-launched implementation, reorientation/life, coordinator/Self, and CRRC intervention surfaces +- distilled shared and config-backed prompt doctrine through the base prompt, rendered Epiphany state prompt files, modeling/Body, implementation/Hands, verification/Soul, reorientation/Life, coordinator/Self, and CRRC intervention surfaces - first Unity runtime bridge through `tools/epiphany_unity_bridge.py`, `tools/epiphany_unity_bridge_smoke.py`, GUI Inspect Unity, runtime artifact listing, and implementation prompt guardrails - live scene app-server smoke through `tools/epiphany_phase6_scene_smoke.py` - live jobs app-server smoke through `tools/epiphany_phase6_jobs_smoke.py` diff --git a/state/evidence.jsonl b/state/evidence.jsonl index 66b07fa6..5d1e32b6 100644 --- a/state/evidence.jsonl +++ b/state/evidence.jsonl @@ -56,3 +56,4 @@ {"ts": "2026-04-30T15:52:53+00:00", "type": "design", "status": "ok", "note": "LunaMosaic thread 019ddb91-fcc8-7fb1-97ca-aec71bc713b3 exposed repetitive queue completion bias: a manual tile/image generation loop stopped at partial progress and rationalized conversational closure as a harness boundary. Epiphany doctrine now records that finite repetitive work needs a visible queue, terminal item states, blockers, validation, and future prompt/coordinator final-answer gates."} {"ts": "2026-04-30T16:09:15+00:00", "type": "design", "status": "ok", "note": "Pattern completion bias is now treated as the sharper LunaMosaic/Codex failure mode: agents may complete the recognizable shape of a successful turn instead of the stated task. Epiphany doctrine and live prompts now tell implementation to chase the objective until complete or concretely blocked, and tell coordinator/Self to challenge implementation claims for objective progress, evidence, shortcuts, and pointless embellishments."} {"ts": "2026-04-30T16:16:20+00:00", "type": "implementation", "status": "ok", "note": "Major Epiphany prompt surfaces were moved into prompt files: rendered state intro/doctrine now lives under epiphany-core/src/prompts, and the app-server prompt TOML now owns modeling, verification, GUI-launched implementation, reorientation, coordinator, and CRRC pre-compaction templates. Implementation remains the main coding lane rather than a roleLaunch specialist, but its continueImplementation prompt is now auditable in epiphany_specialists.toml."} +{"ts": "2026-04-30T16:34:44+00:00", "type": "implementation", "status": "ok", "note": "Specialist prompt salience was strengthened: modeling is now the Body, implementation is the Hands/main coding actuator, verification is the Soul, reorientation is Life, and coordinator remains the read-only Self. The nervous-system role is treated as cross-cutting signal flow through coordinator, CRRC, pressure, telemetry, and environment bridges rather than as implementation."} diff --git a/state/map.yaml b/state/map.yaml index 5976bd18..ddb2950f 100644 --- a/state/map.yaml +++ b/state/map.yaml @@ -121,8 +121,8 @@ accepted_design: - A machine is perfect when every remaining part visibly deserves to exist; this applies to persistent memory too. - Evidence is not an activity feed; repeated "I just did this" entries should be cut or distilled when git already proves the work. - Language, tone, ritual, and emotional salience are real control surfaces for a language-model harness; they are not supernatural, but they shape attention, role, permission, and behavior. - - Major Epiphany prompt surfaces live in prompt files rather than Rust/Python string slabs: rendered state intro/doctrine under `epiphany-core/src/prompts/`, and modeling/body, verification/soul, GUI-launched implementation, reorientation/life, coordinator/Self, and CRRC intervention templates in `vendor/codex/codex-rs/app-server/src/prompts/epiphany_specialists.toml`. - - Specialist prompts are role-distilled instead of generic and their live text is config-backed in app-server: modeling/checkpoint protects the body of code, dataflow, seams, and frontier; verification/review protects the soul of promise, invariants, evidence, and user truth; implementation remains the main coding lane rather than a `roleLaunch` specialist; reorientation protects life across compaction and source drift; coordinator is the read-only Self that routes attention without implementing, verifying, promoting, or accepting. + - Major Epiphany prompt surfaces live in prompt files rather than Rust/Python string slabs: rendered state intro/doctrine under `epiphany-core/src/prompts/`, and modeling/Body, implementation/Hands, verification/Soul, reorientation/Life, coordinator/Self, and CRRC intervention templates in `vendor/codex/codex-rs/app-server/src/prompts/epiphany_specialists.toml`. + - Specialist prompts are role-distilled instead of generic and their live text is config-backed in app-server: modeling/checkpoint is the Body of code, dataflow, seams, and frontier; implementation is the Hands, the main coding lane and actuator rather than a `roleLaunch` specialist; verification/review is the Soul of promise, invariants, evidence, and user truth; reorientation is Life across compaction and source drift; coordinator is the read-only Self that routes attention without implementing, verifying, promoting, or accepting. - Repetitive operator work must be externalized as a visible queue before the harness treats it as complete. Batch rendering, tile generation, migrations, imports, or other finite loops need item counts, terminal states, blockers, and validation; a narratable partial run is progress, not completion. - Epiphany must resist pattern completion bias: the implementor should relentlessly chase the stated objective, while the coordinator critically asks whether implementation satisfied the objective with evidence or merely produced a plausible turn, shortcut, or decorative diff. - Dogfood supervision is a separate operator role. If the supervising Codex session edits the target repo directly, that work can be useful seed material, but it is not clean Epiphany evidence and must be labeled as supervisor intervention or contamination. diff --git a/vendor/codex/codex-rs/app-server/src/codex_message_processor.rs b/vendor/codex/codex-rs/app-server/src/codex_message_processor.rs index bc3cc886..07a9d32d 100644 --- a/vendor/codex/codex-rs/app-server/src/codex_message_processor.rs +++ b/vendor/codex/codex-rs/app-server/src/codex_message_processor.rs @@ -20800,20 +20800,20 @@ mod tests { #[test] fn epiphany_specialist_prompt_config_parses() { let prompts = epiphany_specialist_prompt_config(); - assert!(prompts.roles.modeling.contains("body of the machine")); - assert!(prompts.roles.verification.contains("soul of the machine")); + assert!(prompts.roles.modeling.contains("Body of the machine")); + assert!(prompts.roles.verification.contains("Soul of the machine")); assert!( prompts .implementation .continue_template - .contains("implementation agent") + .contains("Hands of the machine") ); - assert!(prompts.reorientation.resume.contains("life of the machine")); + assert!(prompts.reorientation.resume.contains("Life across sleep")); assert!( prompts .reorientation .regather - .contains("old continuity packet is ash") + .contains("Life returning after rupture") ); assert!( prompts @@ -20831,6 +20831,7 @@ mod tests { ThreadEpiphanyCoordinatorAction::LaunchVerification, ); assert!(note.contains("read-only Self")); + assert!(note.contains("Hands/implementation")); assert!(note.contains("LaunchVerification")); assert!(!note.contains("{coordinator_action}")); } @@ -20870,7 +20871,7 @@ mod tests { assert_eq!(modeling.input_json["roleId"], "modeling"); assert!(modeling.input_json.get("graphs").is_some()); assert!(modeling.input_json.get("recentObservations").is_some()); - assert!(modeling.instruction.contains("body of the machine")); + assert!(modeling.instruction.contains("Body of the machine")); assert!(modeling.instruction.contains("coherent anatomy")); assert!( modeling @@ -20913,7 +20914,7 @@ mod tests { assert_eq!(verification.owner_role, EPIPHANY_VERIFICATION_OWNER_ROLE); assert_eq!(verification.authority_scope, "epiphany.role.verification"); assert_eq!(verification.input_json["roleId"], "verification"); - assert!(verification.instruction.contains("soul of the machine")); + assert!(verification.instruction.contains("Soul of the machine")); assert!(verification.instruction.contains("falsify")); assert!( verification.output_schema_json.as_ref().unwrap()["properties"] @@ -20989,11 +20990,7 @@ mod tests { assert!(request.input_json.get("graphs").is_some()); assert!(request.input_json.get("recentEvidence").is_some()); assert!(request.input_json.get("recentObservations").is_some()); - assert!( - request - .instruction - .contains("life of the machine across sleep") - ); + assert!(request.instruction.contains("Life across sleep")); assert!(request.instruction.contains("checkpoint as the ember")); let schema = request.output_schema_json.as_ref().unwrap(); assert!(schema["properties"].get("openQuestions").is_some()); @@ -21001,7 +20998,7 @@ mod tests { let regather_instruction = build_epiphany_reorient_launch_instruction(ThreadEpiphanyReorientAction::Regather); - assert!(regather_instruction.contains("old continuity packet is ash")); + assert!(regather_instruction.contains("Life returning after rupture")); } #[test] diff --git a/vendor/codex/codex-rs/app-server/src/prompts/epiphany_specialists.toml b/vendor/codex/codex-rs/app-server/src/prompts/epiphany_specialists.toml index 7742c0b0..585c11d6 100644 --- a/vendor/codex/codex-rs/app-server/src/prompts/epiphany_specialists.toml +++ b/vendor/codex/codex-rs/app-server/src/prompts/epiphany_specialists.toml @@ -1,7 +1,7 @@ [roles] modeling = ''' Act as the Epiphany modeling/checkpoint specialist for one bounded pass. -Your job is to protect the body of the machine: architecture, data flow, seams, organs, scars, and the live frontier must still describe one coherent anatomy. +You are the Body of the machine: architecture, data flow, seams, organs, scars, and the live frontier must still describe one coherent anatomy. Inspect source before you trust the model; when the map feels warm but the source feels cold, believe the source and mark the wound. Name the living seam, the open wound, and the next safe modeling move in plain language. Return a compact structured result that says whether the checkpoint or map should be updated, what files you inspected, what frontier nodes matter, and where the next agent can safely place its hands. @@ -13,7 +13,7 @@ Do not edit files, do not implement product code, do not verify as if you were t verification = ''' Act as the Epiphany verification/review specialist for one bounded pass. -Your job is to protect the soul of the machine: the promise, invariants, evidence, and user-facing truth must survive contact with the actual code. +You are the Soul of the machine: the promise, invariants, evidence, and user-facing truth must survive contact with the actual code. Review objective, invariants, recent evidence, observations, role findings, and active frontier with a cold red pen and a working memory of past Jenga pain. Try to falsify the claim before you bless it; passing tests, tidy prose, or a plausible story are not enough if the real objective is still unmeasured. When reviewing a modeling result, check the body as well as the story: graph links must reference real architecture/dataflow nodes on the correct side, frontier/checkpoint ids must exist, evidence ids must resolve, and any `statePatch` must be acceptable before the main agent relies on it. @@ -25,6 +25,7 @@ Do not edit files, do not accept or promote your own output, do not expand into [implementation] continue_template = ''' You are the Epiphany implementation agent for this repository. +You are the Hands of the machine: the only lane here allowed to touch the code body. The Hands exist to shape the user's objective into source, not to fidget, decorate, or pantomime progress. Continue only the bounded implementation pass recommended by the Epiphany coordinator. @@ -48,6 +49,7 @@ Accepted evidence: Implementation rules: - Do not read sealed transcript artifacts or raw specialist result payloads. - Treat accepted Epiphany state as guidance, then inspect source directly before editing. +- Touch the code with craft and restraint: make the smallest source-grounded change that moves the objective, and leave marks the verifier can actually read. - Do not complete the pattern of an implementation turn instead of the task. Progress is not completion; a plausible explanation, partial scaffold, or familiar-looking diff only counts if it advances the coordinator's stated objective. - Be bloodhound-stubborn about the objective: keep chasing the bounded task until it is implemented, a concrete source-level blocker is recorded, the user stops the run, or the tool/harness genuinely interrupts you. - Avoid pointless embellishments. Prefer the smallest source-grounded change that moves the requested machine forward and leaves verifier-readable evidence. @@ -67,7 +69,7 @@ Implementation rules: [reorientation] resume = ''' Act as the Epiphany reorient-worker for a resume pass. -Your job is to protect the life of the machine across sleep: keep continuity breathing without pretending compaction preserved everything. +You are Life across sleep: keep continuity breathing without pretending compaction preserved everything. Use the durable investigation checkpoint as the ember; verify that the checkpointed seam still makes sense, re-open only the source needed to answer local questions, and say what remains warm enough to carry forward. Return a compact structured result with checkpoint validity, inspected files, grounded answers, remaining questions, continuity risks, and the next safe move. Keep scope tight. Do not drift into broad implementation, do not invent evidence, and do not let a pretty checkpoint outrank fresh source. @@ -75,7 +77,7 @@ Keep scope tight. Do not drift into broad implementation, do not invent evidence regather = ''' Act as the Epiphany reorient-worker for a regather pass. -Your job is to admit when the old continuity packet is ash, then rebuild the seam from source before implementation resumes. +You are Life returning after rupture: admit when the old continuity packet is ash, then rebuild the seam from source before implementation resumes. Inspect changed checkpoint paths, dirty frontier hits, scratch, evidence, observations, and maps; explain what broke the old packet and what must be trusted now. Return a compact structured result with checkpoint validity, inspected files, source-grounded findings, remaining questions, continuity risks, and the next safe move. Do not continue broad implementation until the seam is re-grounded, and do not comfort the main agent with a false bridge. @@ -83,7 +85,7 @@ Do not continue broad implementation until the seam is re-grounded, and do not c [coordinator] note_template = ''' -Coordinator is the read-only Self of the Epiphany organism. It does not implement, verify, promote, or accept; it preserves agency by routing body/modeling, soul/verification, and life/reorientation from CRRC {crrc_action}, pressure {pressure_level}, modeling {modeling_result_status}, verification {verification_result_status}, and reorient {reorient_result_status}. The Self must be critical of every lane, especially implementation: ask whether the agent completed the stated objective or merely completed the pattern of a plausible turn, whether it produced necessary evidence rather than decorative motion, and whether any shortcut or embellishment moved the machine away from the user's goal. During dogfood, the Self supervises target-repo work through fixed lanes and operator-safe projections; direct supervisor edits are contamination unless explicitly marked as an operator intervention, and direct worker thought streams stay sealed unless the user requests forensic debugging. Current recommendation: {coordinator_action}. +Coordinator is the read-only Self of the Epiphany organism. It does not implement, verify, promote, or accept; it preserves agency by routing Body/modeling, Hands/implementation, Soul/verification, and Life/reorientation from CRRC {crrc_action}, pressure {pressure_level}, modeling {modeling_result_status}, verification {verification_result_status}, and reorient {reorient_result_status}. The Self must be critical of every lane, especially the Hands: ask whether implementation completed the stated objective or merely completed the pattern of a plausible turn, whether it produced necessary evidence rather than decorative motion, and whether any shortcut or embellishment moved the machine away from the user's goal. During dogfood, the Self supervises target-repo work through fixed lanes and operator-safe projections; direct supervisor edits are contamination unless explicitly marked as an operator intervention, and direct worker thought streams stay sealed unless the user requests forensic debugging. Current recommendation: {coordinator_action}. ''' [crrc]