Extract Epiphany route handlers

notes/fresh-workspace-handoff.md

@@ -431,14 +431,19 @@ pre-compaction checkpoint projection into
 processor to about 19,232 lines. The tenth cut moved CRRC/coordinator/role-board
 projection plus acceptance/evidence signal helpers into
 `vendor/codex/codex-rs/app-server/src/epiphany_coordinator.rs`, taking the
-processor to about 18,362 lines.
+processor to about 18,362 lines. The eleventh cut moved the Epiphany JSON-RPC
+route-handler cluster into the child module
+`vendor/codex/codex-rs/app-server/src/codex_message_processor/epiphany_routes.rs`,
+taking the processor to about 16,088 lines. This route child module still uses
+parent-internal visibility; it is a staging wound, not final purity.
 
 Also: MCP itself is allowed to be JSON. The target is not "replace MCP JSON";
 the target is an Epiphany-owned boundary that speaks typed Epiphany
 intent/result/receipt documents internally and normal MCP JSON-RPC externally.
 
-Continue with the actual whale-carcass cut: extract Epiphany route handlers,
-accept/launch mutations, and remaining policy-shaped code out of
+Continue with the actual whale-carcass cut: split the Epiphany route child
+module into read-only routes versus mutation/launch/accept routes, then move
+mutation policy and runtime authority out of
 `codex_message_processor.rs` into Epiphany-owned app-server modules, moving
 logic further into `epiphany-core` whenever it owns real policy. Success is a
 visibly smaller `codex_message_processor.rs`, not merely nicer payload names. Do

notes/json-contamination-ledger.md

@@ -62,6 +62,6 @@ Rule: JSON is allowed at external schema/wire boundaries. Inside Epiphany, live
 3. Done: replace role `statePatch` JSON with typed map/planning/graph patch documents. `EpiphanyRoleFindingInterpretation` now carries `EpiphanyRoleStatePatchDocument`; app-server maps it to the legacy protocol patch without JSON round-tripping.
 4. Done: replace runtime job result JSON projections. Runtime-spine results now project through typed role/reorient interpreters instead of `runtime_job_result_to_role_json` and `runtime_job_result_to_reorient_json`.
 5. Done: replace app-server launch protocol `input_json` / `output_schema_json` with typed launch documents and `output_contract_id`.
-6. Continue the whale-carcass cut: the first cuts moved Epiphany launch doctrine and protocol-to-core launch document mapping into `epiphany_launch.rs`, role/reorient result projection into `epiphany_results.rs`, scene projection into `epiphany_scene.rs`, freshness/reorientation mapping into `epiphany_reorient.rs`, context/planning/graph-query projection into `epiphany_context.rs`, jobs projection into `epiphany_jobs.rs`, retrieve projection into `epiphany_retrieve.rs`, pressure/pre-compaction checkpoint projection into `epiphany_pressure.rs`, and CRRC/coordinator/role-board projection plus acceptance/evidence signal helpers into `epiphany_coordinator.rs`, reducing `codex_message_processor.rs` from about 21,263 to 18,362 lines. Next move route handlers, accept/launch mutations, and remaining policy-shaped code out of the processor; success means the processor keeps shrinking and ownership gets clearer, not merely better typed.
+6. Continue the whale-carcass cut: the first cuts moved Epiphany launch doctrine and protocol-to-core launch document mapping into `epiphany_launch.rs`, role/reorient result projection into `epiphany_results.rs`, scene projection into `epiphany_scene.rs`, freshness/reorientation mapping into `epiphany_reorient.rs`, context/planning/graph-query projection into `epiphany_context.rs`, jobs projection into `epiphany_jobs.rs`, retrieve projection into `epiphany_retrieve.rs`, pressure/pre-compaction checkpoint projection into `epiphany_pressure.rs`, CRRC/coordinator/role-board projection plus acceptance/evidence signal helpers into `epiphany_coordinator.rs`, and the Epiphany JSON-RPC route-handler cluster into `codex_message_processor/epiphany_routes.rs`, reducing `codex_message_processor.rs` from about 21,263 to 16,088 lines. Next split read-only routes from mutation/launch/accept routes and move mutation policy toward native CultNet/CultCache contracts; success means the processor keeps shrinking and ownership gets clearer, not merely better typed.
 7. Seal MCP payloads behind an Epiphany boundary that speaks typed Epiphany documents internally and MCP JSON externally.
 8. Audit heartbeat cognition values and either type them or explicitly expire them.

state/map.yaml

@@ -278,5 +278,5 @@ rejected_paths:
     reason: making Epiphany cleaner inside Codex still preserves the wrong organ; Codex must be starved down to OpenAI subscription auth/model transport, while Epiphany data and subsystem communication move to typed CultCache/CultNet.
 
 current_status:
-  summary: The Codex starvation pass has five typing receipts plus ten real carcass cuts: Epiphany launch doctrine/prompt/builders and protocol-to-core launch document mapping moved into `vendor/codex/codex-rs/app-server/src/epiphany_launch.rs`, role/reorient result projection/note rendering moved into `vendor/codex/codex-rs/app-server/src/epiphany_results.rs`, scene projection moved into `vendor/codex/codex-rs/app-server/src/epiphany_scene.rs`, freshness/reorientation input mapping moved into `vendor/codex/codex-rs/app-server/src/epiphany_reorient.rs`, context/planning/graph-query projection moved into `vendor/codex/codex-rs/app-server/src/epiphany_context.rs`, jobs projection moved into `vendor/codex/codex-rs/app-server/src/epiphany_jobs.rs`, retrieve projection moved into `vendor/codex/codex-rs/app-server/src/epiphany_retrieve.rs`, pressure/pre-compaction checkpoint projection moved into `vendor/codex/codex-rs/app-server/src/epiphany_pressure.rs`, and CRRC/coordinator/role-board projection plus acceptance/evidence signal helpers moved into `vendor/codex/codex-rs/app-server/src/epiphany_coordinator.rs`. The processor is down from about 21,263 lines to 18,362 lines. This is progress, not absolution: route handlers, accept/launch mutations, and tests still keep too much Epiphany inside Codex. MCP itself is correctly JSON at its protocol edge; the target is typed Epiphany intent/result/receipt wrappers around MCP, not replacing MCP JSON.
-  next_action: Continue the actual whale-carcass cut: extract Epiphany route handlers and remaining mutation orchestration out of `codex_message_processor.rs` into Epiphany-owned app-server modules, moving logic further into `epiphany-core` whenever it owns real policy. Success metric remains a visibly smaller processor and clearer ownership, not merely typed payloads.
+  summary: The Codex starvation pass has five typing receipts plus eleven real carcass cuts: Epiphany launch doctrine/prompt/builders and protocol-to-core launch document mapping moved into `vendor/codex/codex-rs/app-server/src/epiphany_launch.rs`, role/reorient result projection/note rendering moved into `vendor/codex/codex-rs/app-server/src/epiphany_results.rs`, scene projection moved into `vendor/codex/codex-rs/app-server/src/epiphany_scene.rs`, freshness/reorientation input mapping moved into `vendor/codex/codex-rs/app-server/src/epiphany_reorient.rs`, context/planning/graph-query projection moved into `vendor/codex/codex-rs/app-server/src/epiphany_context.rs`, jobs projection moved into `vendor/codex/codex-rs/app-server/src/epiphany_jobs.rs`, retrieve projection moved into `vendor/codex/codex-rs/app-server/src/epiphany_retrieve.rs`, pressure/pre-compaction checkpoint projection moved into `vendor/codex/codex-rs/app-server/src/epiphany_pressure.rs`, CRRC/coordinator/role-board projection plus acceptance/evidence signal helpers moved into `vendor/codex/codex-rs/app-server/src/epiphany_coordinator.rs`, and the Epiphany JSON-RPC route-handler cluster moved into child module `vendor/codex/codex-rs/app-server/src/codex_message_processor/epiphany_routes.rs`. The processor is down from about 21,263 lines to 16,088 lines. This is progress, not absolution: the route module still has parent-internal visibility and accept/launch mutations still live in the Codex adapter layer. MCP itself is correctly JSON at its protocol edge; the target is typed Epiphany intent/result/receipt wrappers around MCP, not replacing MCP JSON.
+  next_action: Continue the actual whale-carcass cut: split the child Epiphany route module into read-only surfaces versus mutation/launch/accept surfaces, then push mutation policy further into `epiphany-core` or native CultNet/CultCache runtime contracts. Success metric remains a visibly smaller processor and clearer ownership, not merely typed payloads.