diff --git a/notes/fresh-workspace-handoff.md b/notes/fresh-workspace-handoff.md index 62d0485b..5b966a4e 100644 --- a/notes/fresh-workspace-handoff.md +++ b/notes/fresh-workspace-handoff.md @@ -419,21 +419,23 @@ mapping into `vendor/codex/codex-rs/app-server/src/epiphany_reorient.rs`, taking the processor to about 19,708 lines. The sixth cut moved context/planning/graph-query projection into `vendor/codex/codex-rs/app-server/src/epiphany_context.rs`, taking the processor -to about 19,462 lines. This is progress, not absolution: handlers, -jobs/roles/coordinator mappers, route orchestration, accept policy plumbing, and +to about 19,462 lines. The seventh cut moved jobs projection into +`vendor/codex/codex-rs/app-server/src/epiphany_jobs.rs`, taking the processor to +about 19,377 lines. This is progress, not absolution: handlers, +roles/coordinator mappers, route orchestration, accept policy plumbing, and tests still keep too much Epiphany inside Codex. 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 jobs/roles/ -coordinator projection mappers, route handlers, 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 -is a visibly smaller `codex_message_processor.rs`, not merely nicer payload -names. Do not resume Rider, Unity, Aquarium, Face, dogfood, planning, app, -skill, marketplace, or bridge expansion until this organ is being cut cleanly. +Continue with the actual whale-carcass cut: extract Epiphany roles/coordinator +projection mappers, route handlers, 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 is a +visibly smaller `codex_message_processor.rs`, not merely nicer payload names. Do +not resume Rider, Unity, Aquarium, Face, dogfood, planning, app, skill, +marketplace, or bridge expansion until this organ is being cut cleanly. The Phase 6 freshness slice is landed. It exposes read-only `thread/epiphany/freshness` from live retrieval summaries plus graph diff --git a/notes/json-contamination-ledger.md b/notes/json-contamination-ledger.md index d4862755..398bbd66 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 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`, and context/planning/graph-query projection into `epiphany_context.rs`, reducing `codex_message_processor.rs` from about 21,263 to 19,462 lines. Next move jobs/roles/coordinator projection mappers, route handlers, 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`, 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`, and jobs projection into `epiphany_jobs.rs`, reducing `codex_message_processor.rs` from about 21,263 to 19,377 lines. Next move roles/coordinator projection mappers, route handlers, 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 1ca8d351..65def2d3 100644 Binary files a/state/ledgers.msgpack and b/state/ledgers.msgpack differ diff --git a/state/map.yaml b/state/map.yaml index 2e9cbca1..01b9e2af 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 six 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`, and context/planning/graph-query projection moved into `vendor/codex/codex-rs/app-server/src/epiphany_context.rs`. The processor is down from about 21,263 lines to 19,462 lines. This is progress, not absolution: route handlers, jobs/roles/coordinator mappers, 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 jobs/roles/coordinator projection mappers and then route handlers 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 seven 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`, and jobs projection moved into `vendor/codex/codex-rs/app-server/src/epiphany_jobs.rs`. The processor is down from about 21,263 lines to 19,377 lines. This is progress, not absolution: route handlers, roles/coordinator mappers, 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 roles/coordinator projection mappers and then route handlers 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 d347089b..5ea0cdf2 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 @@ -8,6 +8,9 @@ use crate::epiphany_context::map_epiphany_graph_query; use crate::epiphany_context::map_epiphany_planning; use crate::epiphany_invalidation::EpiphanyInvalidationManager; use crate::epiphany_invalidation::EpiphanyInvalidationSnapshot; +use crate::epiphany_jobs::epiphany_blocked_state_job; +use crate::epiphany_jobs::map_core_epiphany_job_kind; +use crate::epiphany_jobs::map_epiphany_jobs; use crate::epiphany_launch::EPIPHANY_IMAGINATION_OWNER_ROLE; use crate::epiphany_launch::EPIPHANY_IMAGINATION_ROLE_BINDING_ID; use crate::epiphany_launch::EPIPHANY_MODELING_OWNER_ROLE; @@ -465,7 +468,6 @@ use codex_protocol::protocol::EpiphanyCodeRef; use codex_protocol::protocol::EpiphanyEvidenceRecord; use codex_protocol::protocol::EpiphanyInvestigationCheckpoint; use codex_protocol::protocol::EpiphanyInvestigationDisposition; -use codex_protocol::protocol::EpiphanyJobKind as CoreEpiphanyJobKind; use codex_protocol::protocol::EpiphanyRetrievalState; use codex_protocol::protocol::EpiphanyRetrievalStatus; use codex_protocol::protocol::EpiphanyRuntimeLink; @@ -531,9 +533,6 @@ use epiphany_core::EpiphanyCrrcReorientAction as CoreEpiphanyCrrcReorientAction; use epiphany_core::EpiphanyCrrcResultStatus as CoreEpiphanyCrrcResultStatus; use epiphany_core::EpiphanyCrrcSceneAction as CoreEpiphanyCrrcSceneAction; use epiphany_core::EpiphanyCrrcStateStatus as CoreEpiphanyCrrcStateStatus; -use epiphany_core::EpiphanyJobStatus as CoreEpiphanyJobStatus; -use epiphany_core::EpiphanyJobView; -use epiphany_core::EpiphanyJobsInput; use epiphany_core::EpiphanyPressure; use epiphany_core::EpiphanyPressureBasis as CoreEpiphanyPressureBasis; use epiphany_core::EpiphanyPressureLevel as CoreEpiphanyPressureLevel; @@ -554,7 +553,6 @@ use epiphany_core::EpiphanyWorkerLaunchDocument; use epiphany_core::build_reorient_acceptance_bundle; use epiphany_core::build_role_acceptance_bundle; use epiphany_core::coordinator_automation_action; -use epiphany_core::derive_jobs; use epiphany_core::derive_pressure_view; use epiphany_core::derive_role_board; use epiphany_core::derive_scene; @@ -14144,89 +14142,6 @@ pub(crate) async fn maybe_run_epiphany_pre_compaction_checkpoint_intervention_fo } } -fn map_epiphany_jobs( - state: Option<&EpiphanyThreadState>, - retrieval_override: Option<&EpiphanyRetrievalState>, -) -> Vec { - derive_jobs(EpiphanyJobsInput { - state, - retrieval_override, - }) - .into_iter() - .map(map_core_epiphany_job_view) - .collect() -} - -fn map_core_epiphany_job_view(job: EpiphanyJobView) -> ThreadEpiphanyJob { - ThreadEpiphanyJob { - id: job.id, - kind: map_core_epiphany_job_kind(job.kind), - scope: job.scope, - owner_role: job.owner_role, - launcher_job_id: None, - authority_scope: job.authority_scope, - backend_job_id: job.runtime_job_id, - status: map_core_epiphany_job_status(job.status), - items_processed: job.items_processed, - items_total: job.items_total, - progress_note: job.progress_note, - last_checkpoint_at_unix_seconds: job.last_checkpoint_at_unix_seconds, - blocking_reason: job.blocking_reason, - active_thread_ids: job.active_thread_ids, - linked_subgoal_ids: job.linked_subgoal_ids, - linked_graph_node_ids: job.linked_graph_node_ids, - } -} - -fn map_core_epiphany_job_kind(kind: CoreEpiphanyJobKind) -> ThreadEpiphanyJobKind { - match kind { - CoreEpiphanyJobKind::Indexing => ThreadEpiphanyJobKind::Indexing, - CoreEpiphanyJobKind::Remap => ThreadEpiphanyJobKind::Remap, - CoreEpiphanyJobKind::Verification => ThreadEpiphanyJobKind::Verification, - CoreEpiphanyJobKind::Specialist => ThreadEpiphanyJobKind::Specialist, - } -} - -fn map_core_epiphany_job_status(status: CoreEpiphanyJobStatus) -> ThreadEpiphanyJobStatus { - match status { - CoreEpiphanyJobStatus::Idle => ThreadEpiphanyJobStatus::Idle, - CoreEpiphanyJobStatus::Needed => ThreadEpiphanyJobStatus::Needed, - CoreEpiphanyJobStatus::Pending => ThreadEpiphanyJobStatus::Pending, - CoreEpiphanyJobStatus::Running => ThreadEpiphanyJobStatus::Running, - CoreEpiphanyJobStatus::Completed => ThreadEpiphanyJobStatus::Completed, - CoreEpiphanyJobStatus::Failed => ThreadEpiphanyJobStatus::Failed, - CoreEpiphanyJobStatus::Cancelled => ThreadEpiphanyJobStatus::Cancelled, - CoreEpiphanyJobStatus::Blocked => ThreadEpiphanyJobStatus::Blocked, - CoreEpiphanyJobStatus::Unavailable => ThreadEpiphanyJobStatus::Unavailable, - } -} - -fn epiphany_blocked_state_job( - id: &str, - kind: ThreadEpiphanyJobKind, - scope: &str, - blocking_reason: &str, -) -> ThreadEpiphanyJob { - ThreadEpiphanyJob { - id: id.to_string(), - kind, - scope: scope.to_string(), - owner_role: "epiphany-harness".to_string(), - launcher_job_id: None, - authority_scope: None, - backend_job_id: None, - status: ThreadEpiphanyJobStatus::Blocked, - items_processed: None, - items_total: None, - progress_note: None, - last_checkpoint_at_unix_seconds: None, - blocking_reason: Some(blocking_reason.to_string()), - active_thread_ids: Vec::new(), - linked_subgoal_ids: Vec::new(), - linked_graph_node_ids: Vec::new(), - } -} - fn thread_epiphany_patch_has_state_replacements(patch: &ThreadEpiphanyUpdatePatch) -> bool { patch.objective.is_some() || patch.active_subgoal_id.is_some() diff --git a/vendor/codex/codex-rs/app-server/src/epiphany_jobs.rs b/vendor/codex/codex-rs/app-server/src/epiphany_jobs.rs new file mode 100644 index 00000000..11535cb1 --- /dev/null +++ b/vendor/codex/codex-rs/app-server/src/epiphany_jobs.rs @@ -0,0 +1,93 @@ +use codex_app_server_protocol::ThreadEpiphanyJob; +use codex_app_server_protocol::ThreadEpiphanyJobKind; +use codex_app_server_protocol::ThreadEpiphanyJobStatus; +use codex_protocol::protocol::EpiphanyJobKind as CoreEpiphanyJobKind; +use codex_protocol::protocol::EpiphanyRetrievalState; +use codex_protocol::protocol::EpiphanyThreadState; +use epiphany_core::EpiphanyJobStatus as CoreEpiphanyJobStatus; +use epiphany_core::EpiphanyJobView; +use epiphany_core::EpiphanyJobsInput; +use epiphany_core::derive_jobs; + +pub(super) fn map_epiphany_jobs( + state: Option<&EpiphanyThreadState>, + retrieval_override: Option<&EpiphanyRetrievalState>, +) -> Vec { + derive_jobs(EpiphanyJobsInput { + state, + retrieval_override, + }) + .into_iter() + .map(map_core_epiphany_job_view) + .collect() +} + +fn map_core_epiphany_job_view(job: EpiphanyJobView) -> ThreadEpiphanyJob { + ThreadEpiphanyJob { + id: job.id, + kind: map_core_epiphany_job_kind(job.kind), + scope: job.scope, + owner_role: job.owner_role, + launcher_job_id: None, + authority_scope: job.authority_scope, + backend_job_id: job.runtime_job_id, + status: map_core_epiphany_job_status(job.status), + items_processed: job.items_processed, + items_total: job.items_total, + progress_note: job.progress_note, + last_checkpoint_at_unix_seconds: job.last_checkpoint_at_unix_seconds, + blocking_reason: job.blocking_reason, + active_thread_ids: job.active_thread_ids, + linked_subgoal_ids: job.linked_subgoal_ids, + linked_graph_node_ids: job.linked_graph_node_ids, + } +} + +pub(super) fn map_core_epiphany_job_kind(kind: CoreEpiphanyJobKind) -> ThreadEpiphanyJobKind { + match kind { + CoreEpiphanyJobKind::Indexing => ThreadEpiphanyJobKind::Indexing, + CoreEpiphanyJobKind::Remap => ThreadEpiphanyJobKind::Remap, + CoreEpiphanyJobKind::Verification => ThreadEpiphanyJobKind::Verification, + CoreEpiphanyJobKind::Specialist => ThreadEpiphanyJobKind::Specialist, + } +} + +fn map_core_epiphany_job_status(status: CoreEpiphanyJobStatus) -> ThreadEpiphanyJobStatus { + match status { + CoreEpiphanyJobStatus::Idle => ThreadEpiphanyJobStatus::Idle, + CoreEpiphanyJobStatus::Needed => ThreadEpiphanyJobStatus::Needed, + CoreEpiphanyJobStatus::Pending => ThreadEpiphanyJobStatus::Pending, + CoreEpiphanyJobStatus::Running => ThreadEpiphanyJobStatus::Running, + CoreEpiphanyJobStatus::Completed => ThreadEpiphanyJobStatus::Completed, + CoreEpiphanyJobStatus::Failed => ThreadEpiphanyJobStatus::Failed, + CoreEpiphanyJobStatus::Cancelled => ThreadEpiphanyJobStatus::Cancelled, + CoreEpiphanyJobStatus::Blocked => ThreadEpiphanyJobStatus::Blocked, + CoreEpiphanyJobStatus::Unavailable => ThreadEpiphanyJobStatus::Unavailable, + } +} + +pub(super) fn epiphany_blocked_state_job( + id: &str, + kind: ThreadEpiphanyJobKind, + scope: &str, + blocking_reason: &str, +) -> ThreadEpiphanyJob { + ThreadEpiphanyJob { + id: id.to_string(), + kind, + scope: scope.to_string(), + owner_role: "epiphany-harness".to_string(), + launcher_job_id: None, + authority_scope: None, + backend_job_id: None, + status: ThreadEpiphanyJobStatus::Blocked, + items_processed: None, + items_total: None, + progress_note: None, + last_checkpoint_at_unix_seconds: None, + blocking_reason: Some(blocking_reason.to_string()), + active_thread_ids: Vec::new(), + linked_subgoal_ids: Vec::new(), + linked_graph_node_ids: Vec::new(), + } +} diff --git a/vendor/codex/codex-rs/app-server/src/lib.rs b/vendor/codex/codex-rs/app-server/src/lib.rs index 271e3b7d..b560d1f9 100644 --- a/vendor/codex/codex-rs/app-server/src/lib.rs +++ b/vendor/codex/codex-rs/app-server/src/lib.rs @@ -77,6 +77,7 @@ mod device_key_api; mod dynamic_tools; mod epiphany_context; mod epiphany_invalidation; +mod epiphany_jobs; mod epiphany_launch; mod epiphany_reorient; mod epiphany_results;