diff --git a/notes/fresh-workspace-handoff.md b/notes/fresh-workspace-handoff.md index a1995889..fac84c45 100644 --- a/notes/fresh-workspace-handoff.md +++ b/notes/fresh-workspace-handoff.md @@ -410,7 +410,9 @@ request builders, output schemas, binding ids, and launch-specific labels into down from about 21,263 lines to 20,596 lines. The second cut moved role/reorient result projection and note rendering into `vendor/codex/codex-rs/app-server/src/epiphany_results.rs`, taking the processor -to about 20,331 lines. This is progress, not absolution: handlers, scene/view +to about 20,331 lines. The third cut moved protocol-to-core launch document +mapping into `epiphany_launch.rs`, taking the processor to about 20,255 lines. +This is progress, not absolution: handlers, scene/view mappers, route orchestration, coordinator glue, accept policy plumbing, and tests still keep too much Epiphany inside Codex. diff --git a/notes/json-contamination-ledger.md b/notes/json-contamination-ledger.md index 71385ab7..91330f3f 100644 --- a/notes/json-contamination-ledger.md +++ b/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 cut moved Epiphany launch doctrine into `epiphany_launch.rs`, and the second moved role/reorient result projection into `epiphany_results.rs`, reducing `codex_message_processor.rs` from about 21,263 to 20,331 lines. Next move route handlers, scene/view projection mappers, coordinator glue, and 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`, and role/reorient result projection into `epiphany_results.rs`, reducing `codex_message_processor.rs` from about 21,263 to 20,255 lines. Next move route handlers, scene/view projection mappers, coordinator glue, and policy-shaped code out of the processor; 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. diff --git a/state/ledgers.msgpack b/state/ledgers.msgpack index 7cb4a332..d1c83c02 100644 Binary files a/state/ledgers.msgpack and b/state/ledgers.msgpack differ diff --git a/state/map.yaml b/state/map.yaml index f0e26b2d..2202e386 100644 --- a/state/map.yaml +++ b/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 two real carcass cuts: Epiphany launch doctrine/prompt/builders moved into `vendor/codex/codex-rs/app-server/src/epiphany_launch.rs`, and role/reorient result projection/note rendering moved into `vendor/codex/codex-rs/app-server/src/epiphany_results.rs`. The processor is down from about 21,263 lines to 20,331 lines. This is progress, not absolution: route handlers, scene/view mappers, coordinator glue, accept policy plumbing, 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. + summary: The Codex starvation pass has five typing receipts plus three 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`, and role/reorient result projection/note rendering moved into `vendor/codex/codex-rs/app-server/src/epiphany_results.rs`. The processor is down from about 21,263 lines to 20,255 lines. This is progress, not absolution: route handlers, scene/view mappers, coordinator glue, accept policy plumbing, 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, scene/view projection mappers, coordinator glue, and remaining policy-shaped code 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. 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 24e1a186..be1c4672 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 @@ -22,6 +22,7 @@ use crate::epiphany_launch::epiphany_role_binding_id; use crate::epiphany_launch::epiphany_role_label; use crate::epiphany_launch::epiphany_role_launch_output_schema; use crate::epiphany_launch::epiphany_specialist_prompt_config; +use crate::epiphany_launch::map_core_worker_launch_document; use crate::epiphany_launch::pressure_level_label; use crate::epiphany_launch::render_epiphany_coordinator_note; use crate::epiphany_results::map_core_role_result_role_id; @@ -233,7 +234,6 @@ use codex_app_server_protocol::ThreadEpiphanyReorientResultResponse; use codex_app_server_protocol::ThreadEpiphanyReorientResultStatus; use codex_app_server_protocol::ThreadEpiphanyReorientSource; use codex_app_server_protocol::ThreadEpiphanyReorientStateStatus; -use codex_app_server_protocol::ThreadEpiphanyReorientWorkerLaunchDocument; use codex_app_server_protocol::ThreadEpiphanyRetrievalFreshness; use codex_app_server_protocol::ThreadEpiphanyRetrievalFreshnessStatus; use codex_app_server_protocol::ThreadEpiphanyRetrieveIndexSummary; @@ -254,7 +254,6 @@ use codex_app_server_protocol::ThreadEpiphanyRoleResultResponse; use codex_app_server_protocol::ThreadEpiphanyRoleResultStatus; use codex_app_server_protocol::ThreadEpiphanyRoleSelfPersistenceStatus; use codex_app_server_protocol::ThreadEpiphanyRoleStatus; -use codex_app_server_protocol::ThreadEpiphanyRoleWorkerLaunchDocument; use codex_app_server_protocol::ThreadEpiphanyRolesSource; use codex_app_server_protocol::ThreadEpiphanyScene; use codex_app_server_protocol::ThreadEpiphanySceneAction; @@ -282,7 +281,6 @@ use codex_app_server_protocol::ThreadEpiphanyViewPlanning; use codex_app_server_protocol::ThreadEpiphanyViewReorient; use codex_app_server_protocol::ThreadEpiphanyViewResponse; use codex_app_server_protocol::ThreadEpiphanyViewRoles; -use codex_app_server_protocol::ThreadEpiphanyWorkerLaunchDocument; use codex_app_server_protocol::ThreadForkParams; use codex_app_server_protocol::ThreadForkResponse; use codex_app_server_protocol::ThreadIncrementElicitationParams; @@ -576,7 +574,6 @@ use epiphany_core::EpiphanyReorientInput; use epiphany_core::EpiphanyReorientPressureLevel as CoreEpiphanyReorientPressureLevel; use epiphany_core::EpiphanyReorientReason as CoreEpiphanyReorientReason; use epiphany_core::EpiphanyReorientStateStatus as CoreEpiphanyReorientStateStatus; -use epiphany_core::EpiphanyReorientWorkerLaunchDocument; use epiphany_core::EpiphanyRetrievalFreshness as CoreEpiphanyRetrievalFreshness; use epiphany_core::EpiphanyRetrievalFreshnessStatus as CoreEpiphanyRetrievalFreshnessStatus; use epiphany_core::EpiphanyRoleAcceptanceFinding; @@ -587,7 +584,6 @@ use epiphany_core::EpiphanyRoleBoardJobStatus; use epiphany_core::EpiphanyRoleBoardLane; use epiphany_core::EpiphanyRoleBoardPlanningSummary; use epiphany_core::EpiphanyRoleStatePatchDocument; -use epiphany_core::EpiphanyRoleWorkerLaunchDocument; use epiphany_core::EpiphanyRuntimeJobSnapshot; use epiphany_core::EpiphanyRuntimeJobStatus; use epiphany_core::EpiphanyScene as CoreEpiphanyScene; @@ -12731,78 +12727,6 @@ fn map_core_epiphany_scene_churn(churn: CoreEpiphanySceneChurn) -> ThreadEpiphan } } -fn map_core_worker_launch_document( - document: ThreadEpiphanyWorkerLaunchDocument, -) -> EpiphanyWorkerLaunchDocument { - match document { - ThreadEpiphanyWorkerLaunchDocument::Role(document) => { - EpiphanyWorkerLaunchDocument::Role(map_core_role_worker_launch_document(document)) - } - ThreadEpiphanyWorkerLaunchDocument::Reorient(document) => { - EpiphanyWorkerLaunchDocument::Reorient(map_core_reorient_worker_launch_document( - document, - )) - } - } -} - -fn map_core_role_worker_launch_document( - document: ThreadEpiphanyRoleWorkerLaunchDocument, -) -> EpiphanyRoleWorkerLaunchDocument { - EpiphanyRoleWorkerLaunchDocument { - thread_id: document.thread_id, - role_id: document.role_id, - state_revision: document.state_revision, - objective: document.objective, - active_subgoal_id: document.active_subgoal_id, - active_subgoals: document.active_subgoals, - active_graph_node_ids: document.active_graph_node_ids, - investigation_checkpoint: document.investigation_checkpoint, - scratch: document.scratch, - invariants: document.invariants, - graphs: document.graphs, - recent_evidence: document.recent_evidence, - recent_observations: document.recent_observations, - graph_frontier: document.graph_frontier, - graph_checkpoint: document.graph_checkpoint, - planning: document.planning, - churn: document.churn, - } -} - -fn map_core_reorient_worker_launch_document( - document: ThreadEpiphanyReorientWorkerLaunchDocument, -) -> EpiphanyReorientWorkerLaunchDocument { - EpiphanyReorientWorkerLaunchDocument { - thread_id: document.thread_id, - mode: document.mode, - checkpoint_id: document.checkpoint_id, - checkpoint_kind: document.checkpoint_kind, - checkpoint_disposition: document.checkpoint_disposition, - checkpoint_focus: document.checkpoint_focus, - checkpoint_summary: document.checkpoint_summary, - checkpoint_next_action: document.checkpoint_next_action, - checkpoint_open_questions: document.checkpoint_open_questions, - checkpoint_evidence_ids: document.checkpoint_evidence_ids, - checkpoint_code_refs: document.checkpoint_code_refs, - decision_reasons: document.decision_reasons, - decision_note: document.decision_note, - pressure_level: document.pressure_level, - retrieval_status: document.retrieval_status, - graph_status: document.graph_status, - watcher_status: document.watcher_status, - checkpoint_dirty_paths: document.checkpoint_dirty_paths, - checkpoint_changed_paths: document.checkpoint_changed_paths, - scratch: document.scratch, - graphs: document.graphs, - recent_evidence: document.recent_evidence, - recent_observations: document.recent_observations, - active_frontier_node_ids: document.active_frontier_node_ids, - linked_subgoal_ids: document.linked_subgoal_ids, - linked_graph_node_ids: document.linked_graph_node_ids, - } -} - fn core_state_patch_from_protocol( patch: &ThreadEpiphanyUpdatePatch, ) -> EpiphanyRoleStatePatchDocument { diff --git a/vendor/codex/codex-rs/app-server/src/epiphany_launch.rs b/vendor/codex/codex-rs/app-server/src/epiphany_launch.rs index 21175d3e..be7d89ad 100644 --- a/vendor/codex/codex-rs/app-server/src/epiphany_launch.rs +++ b/vendor/codex/codex-rs/app-server/src/epiphany_launch.rs @@ -7,8 +7,11 @@ use codex_app_server_protocol::ThreadEpiphanyPressureLevel; use codex_app_server_protocol::ThreadEpiphanyReorientAction; use codex_app_server_protocol::ThreadEpiphanyReorientDecision; use codex_app_server_protocol::ThreadEpiphanyReorientReason; +use codex_app_server_protocol::ThreadEpiphanyReorientWorkerLaunchDocument; use codex_app_server_protocol::ThreadEpiphanyRetrievalFreshnessStatus; use codex_app_server_protocol::ThreadEpiphanyRoleId; +use codex_app_server_protocol::ThreadEpiphanyRoleWorkerLaunchDocument; +use codex_app_server_protocol::ThreadEpiphanyWorkerLaunchDocument; use codex_core::EpiphanyJobLaunchRequest; use codex_protocol::protocol::EpiphanyInvestigationCheckpoint; use codex_protocol::protocol::EpiphanyInvestigationDisposition; @@ -578,6 +581,78 @@ pub(super) fn build_epiphany_reorient_launch_instruction( epiphany_agent_prompt_with_memory(body) } +pub(super) fn map_core_worker_launch_document( + document: ThreadEpiphanyWorkerLaunchDocument, +) -> EpiphanyWorkerLaunchDocument { + match document { + ThreadEpiphanyWorkerLaunchDocument::Role(document) => { + EpiphanyWorkerLaunchDocument::Role(map_core_role_worker_launch_document(document)) + } + ThreadEpiphanyWorkerLaunchDocument::Reorient(document) => { + EpiphanyWorkerLaunchDocument::Reorient(map_core_reorient_worker_launch_document( + document, + )) + } + } +} + +fn map_core_role_worker_launch_document( + document: ThreadEpiphanyRoleWorkerLaunchDocument, +) -> EpiphanyRoleWorkerLaunchDocument { + EpiphanyRoleWorkerLaunchDocument { + thread_id: document.thread_id, + role_id: document.role_id, + state_revision: document.state_revision, + objective: document.objective, + active_subgoal_id: document.active_subgoal_id, + active_subgoals: document.active_subgoals, + active_graph_node_ids: document.active_graph_node_ids, + investigation_checkpoint: document.investigation_checkpoint, + scratch: document.scratch, + invariants: document.invariants, + graphs: document.graphs, + recent_evidence: document.recent_evidence, + recent_observations: document.recent_observations, + graph_frontier: document.graph_frontier, + graph_checkpoint: document.graph_checkpoint, + planning: document.planning, + churn: document.churn, + } +} + +fn map_core_reorient_worker_launch_document( + document: ThreadEpiphanyReorientWorkerLaunchDocument, +) -> EpiphanyReorientWorkerLaunchDocument { + EpiphanyReorientWorkerLaunchDocument { + thread_id: document.thread_id, + mode: document.mode, + checkpoint_id: document.checkpoint_id, + checkpoint_kind: document.checkpoint_kind, + checkpoint_disposition: document.checkpoint_disposition, + checkpoint_focus: document.checkpoint_focus, + checkpoint_summary: document.checkpoint_summary, + checkpoint_next_action: document.checkpoint_next_action, + checkpoint_open_questions: document.checkpoint_open_questions, + checkpoint_evidence_ids: document.checkpoint_evidence_ids, + checkpoint_code_refs: document.checkpoint_code_refs, + decision_reasons: document.decision_reasons, + decision_note: document.decision_note, + pressure_level: document.pressure_level, + retrieval_status: document.retrieval_status, + graph_status: document.graph_status, + watcher_status: document.watcher_status, + checkpoint_dirty_paths: document.checkpoint_dirty_paths, + checkpoint_changed_paths: document.checkpoint_changed_paths, + scratch: document.scratch, + graphs: document.graphs, + recent_evidence: document.recent_evidence, + recent_observations: document.recent_observations, + active_frontier_node_ids: document.active_frontier_node_ids, + linked_subgoal_ids: document.linked_subgoal_ids, + linked_graph_node_ids: document.linked_graph_node_ids, + } +} + pub(super) fn render_epiphany_coordinator_note( crrc_action: codex_app_server_protocol::ThreadEpiphanyCrrcAction, pressure_level: ThreadEpiphanyPressureLevel,