From 15b079db93fa1e9627f1c09d81a940c644aef9aa Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Thu, 28 May 2026 08:02:45 +0100 Subject: [PATCH] Expose typed tool invocation status --- epiphany-core/src/bin/epiphany-mvp-status.rs | 58 +++++++ .../src/bin/epiphany-runtime-spine.rs | 6 + epiphany-core/src/lib.rs | 2 + epiphany-core/src/runtime_spine.rs | 149 ++++++++++++++++++ notes/fresh-workspace-handoff.md | 3 +- state/ledgers.msgpack | Bin 157679 -> 157954 bytes state/map.yaml | 4 +- 7 files changed, 220 insertions(+), 2 deletions(-) diff --git a/epiphany-core/src/bin/epiphany-mvp-status.rs b/epiphany-core/src/bin/epiphany-mvp-status.rs index 49ef51c0..74c2a2f5 100644 --- a/epiphany-core/src/bin/epiphany-mvp-status.rs +++ b/epiphany-core/src/bin/epiphany-mvp-status.rs @@ -48,6 +48,7 @@ use std::time::{Duration, Instant}; const DEFAULT_APP_SERVER: &str = r"C:\Users\Meta\.cargo-target-codex\debug\codex-app-server.exe"; const DEFAULT_CARGO_TARGET_DIR: &str = r"C:\Users\Meta\.cargo-target-codex"; const DEFAULT_THREAD_STATE_STORE: &str = "state/thread-state.msgpack"; +const DEFAULT_RUNTIME_STORE: &str = "state/runtime-spine.msgpack"; const REORIENT_BINDING_ID: &str = "reorient-worker"; const IMAGINATION_BINDING_ID: &str = "imagination-synthesis-worker"; const MODELING_BINDING_ID: &str = "modeling-checkpoint-worker"; @@ -107,6 +108,7 @@ struct Args { thread_id: Option, cwd: PathBuf, thread_state_store: PathBuf, + runtime_store: PathBuf, ephemeral: bool, json: bool, result: Option, @@ -127,6 +129,7 @@ impl Args { thread_id: None, cwd: root.clone(), thread_state_store: PathBuf::from(DEFAULT_THREAD_STATE_STORE), + runtime_store: PathBuf::from(DEFAULT_RUNTIME_STORE), ephemeral: true, json: false, result: None, @@ -149,6 +152,9 @@ impl Args { "--thread-state-store" => { parsed.thread_state_store = take_path(&mut args, "--thread-state-store")? } + "--runtime-store" => { + parsed.runtime_store = take_path(&mut args, "--runtime-store")? + } "--ephemeral" => parsed.ephemeral = true, "--no-ephemeral" => parsed.ephemeral = false, "--json" => parsed.json = true, @@ -172,6 +178,7 @@ fn run_status(args: &Args) -> Result { fn run_native_status(args: &Args) -> Result { let cwd = absolute_path(&args.cwd)?; let store_path = absolute_path(&args.thread_state_store)?; + let runtime_store_path = absolute_path(&args.runtime_store)?; let state_entry = if store_path.exists() { load_thread_state_entry(&store_path) .with_context(|| format!("failed to load {}", store_path.display()))? @@ -325,6 +332,7 @@ fn run_native_status(args: &Args) -> Result { reorient_finding_accepted: finding_signals.reorient_finding_accepted, }); let coordinator_json = coordinator_status_json(&coordinator)?; + let tool_invocations = native_tool_invocation_surface(&runtime_store_path)?; let root = env::current_dir().context("failed to resolve current directory")?; let native_aux = native_auxiliary_status(&root)?; @@ -359,6 +367,7 @@ fn run_native_status(args: &Args) -> Result { "recommendation": recommendation, }, "coordinator": coordinator_json, + "tools": tool_invocations.clone(), }, "scene": { "threadId": thread_id, @@ -404,6 +413,7 @@ fn run_native_status(args: &Args) -> Result { "recommendation": recommendation, }, "coordinator": coordinator_json, + "tools": tool_invocations, "heartbeat": native_aux.heartbeat, "face": native_aux.face, "voidMemory": native_aux.void_memory, @@ -500,6 +510,8 @@ fn run_codex_status(args: &Args) -> Result { .get("coordinator") .cloned() .unwrap_or_else(|| json!(null)); + let runtime_store_path = absolute_path(&args.runtime_store)?; + let tool_invocations = native_tool_invocation_surface(&runtime_store_path)?; let root = env::current_dir().context("failed to resolve current directory")?; let native_aux = native_auxiliary_status(&root)?; let status = json!({ @@ -516,6 +528,7 @@ fn run_codex_status(args: &Args) -> Result { "reorientResult": reorient_result, "crrc": crrc, "coordinator": coordinator, + "tools": tool_invocations, "heartbeat": native_aux.heartbeat, "face": native_aux.face, "voidMemory": native_aux.void_memory, @@ -585,6 +598,22 @@ fn native_role_result(binding_id: &str) -> Value { }) } +fn native_tool_invocation_surface(runtime_store: &Path) -> Result { + let spine_status = epiphany_core::runtime_spine_status(runtime_store)?; + let invocations = epiphany_core::runtime_tool_invocation_statuses(runtime_store)?; + Ok(json!({ + "source": "native", + "runtimeStore": runtime_store.display().to_string(), + "summary": { + "present": spine_status.present, + "intentCount": spine_status.tool_invocation_intents, + "pendingCount": spine_status.pending_tool_invocations, + "receiptCount": spine_status.tool_invocation_receipts, + }, + "invocations": invocations, + })) +} + fn coordinator_status_json(status: &epiphany_core::EpiphanyCoordinatorStatus) -> Result { let mut value = serde_json::to_value(status).context("failed to encode coordinator status")?; let decision = value @@ -1043,6 +1072,35 @@ pub fn render_status(status: &Value) -> String { } } } + let tools = &status["tools"]; + let tool_summary = &tools["summary"]; + lines.extend([ + String::new(), + "Tools".to_string(), + format!( + "- intents: {} pending: {} receipts: {}", + maybe(&tool_summary["intentCount"], "0"), + maybe(&tool_summary["pendingCount"], "0"), + maybe(&tool_summary["receiptCount"], "0") + ), + format!("- runtime store: {}", maybe(&tools["runtimeStore"], "none")), + ]); + if let Some(invocations) = tools["invocations"].as_array() { + if invocations.is_empty() { + lines.push("- latest: none".to_string()); + } else { + for invocation in invocations.iter().rev().take(5) { + lines.push(format!( + "- {}: {} {}/{} ({})", + maybe(&invocation["intentId"], "unknown"), + maybe(&invocation["status"], "unknown"), + maybe(&invocation["server"], "unknown"), + maybe(&invocation["toolName"], "unknown"), + maybe(&invocation["adapter"], "unknown") + )); + } + } + } lines.extend([ String::new(), "Available Actions".to_string(), diff --git a/epiphany-core/src/bin/epiphany-runtime-spine.rs b/epiphany-core/src/bin/epiphany-runtime-spine.rs index 12fe31ec..499209c8 100644 --- a/epiphany-core/src/bin/epiphany-runtime-spine.rs +++ b/epiphany-core/src/bin/epiphany-runtime-spine.rs @@ -64,6 +64,12 @@ fn main() -> Result<()> { println!("jobs: {} open: {}", status.jobs, status.open_jobs); println!("job results: {}", status.job_results); println!("events: {}", status.events); + println!( + "tool invocations: {} pending: {} receipts: {}", + status.tool_invocation_intents, + status.pending_tool_invocations, + status.tool_invocation_receipts + ); if !status.supported_document_types.is_empty() { println!("documents: {}", status.supported_document_types.join(", ")); } diff --git a/epiphany-core/src/lib.rs b/epiphany-core/src/lib.rs index 2d4a6d85..2f838178 100644 --- a/epiphany-core/src/lib.rs +++ b/epiphany-core/src/lib.rs @@ -353,6 +353,7 @@ pub use runtime_spine::EpiphanyRuntimeSession; pub use runtime_spine::EpiphanyRuntimeSessionStatus; pub use runtime_spine::EpiphanyRuntimeSpineStatus; pub use runtime_spine::EpiphanyRuntimeWorkerLaunchRequest; +pub use runtime_spine::EpiphanyToolInvocationStatus; pub use runtime_spine::RUNTIME_EVENT_TYPE; pub use runtime_spine::RUNTIME_IDENTITY_KEY; pub use runtime_spine::RUNTIME_IDENTITY_TYPE; @@ -394,6 +395,7 @@ pub use runtime_spine::runtime_role_worker_result; pub use runtime_spine::runtime_schema_catalog_response; pub use runtime_spine::runtime_spine_cache; pub use runtime_spine::runtime_spine_status; +pub use runtime_spine::runtime_tool_invocation_statuses; pub use runtime_spine::runtime_worker_launch_request; pub use runtime_spine::write_runtime_hello_frame; pub use runtime_spine::write_runtime_schema_catalog_json; diff --git a/epiphany-core/src/runtime_spine.rs b/epiphany-core/src/runtime_spine.rs index feaa62be..4c62ef3a 100644 --- a/epiphany-core/src/runtime_spine.rs +++ b/epiphany-core/src/runtime_spine.rs @@ -89,6 +89,7 @@ use epiphany_tool_adapter::EpiphanyToolInvocationReceipt; use serde::Deserialize; use serde::Serialize; use std::collections::BTreeMap; +use std::collections::BTreeSet; use std::fs; use std::path::Path; use std::path::PathBuf; @@ -535,9 +536,28 @@ pub struct EpiphanyRuntimeSpineStatus { pub open_jobs: usize, pub job_results: usize, pub events: usize, + pub tool_invocation_intents: usize, + pub tool_invocation_receipts: usize, + pub pending_tool_invocations: usize, pub supported_document_types: Vec, } +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct EpiphanyToolInvocationStatus { + pub intent_id: String, + pub adapter: String, + pub server: String, + pub tool_name: String, + pub caller: String, + pub reason: String, + pub created_at: String, + pub status: String, + pub receipt_id: Option, + pub completed_at: Option, + pub error: Option, +} + #[derive(Clone, Debug, PartialEq, Eq)] pub struct RuntimeSpineInitOptions { pub runtime_id: String, @@ -1240,6 +1260,9 @@ pub fn runtime_spine_status(store_path: impl AsRef) -> Result) -> Result()?; let job_results = cache.get_all::()?; let events = cache.get_all::()?; + let tool_intents = cache.get_all::()?; + let tool_receipts = cache.get_all::()?; + let receipt_intent_ids = tool_receipts + .iter() + .map(|receipt| receipt.intent_id.as_str()) + .collect::>(); let active_sessions = sessions .iter() .filter(|session| { @@ -1284,12 +1313,65 @@ pub fn runtime_spine_status(store_path: impl AsRef) -> Result, +) -> Result> { + let store_path = store_path.as_ref(); + if !store_path.exists() { + return Ok(Vec::new()); + } + let mut cache = runtime_spine_cache(store_path)?; + cache + .pull_all_backing_stores() + .with_context(|| format!("failed to read runtime spine {}", store_path.display()))?; + let mut receipts = cache + .get_all::()? + .into_iter() + .map(|receipt| (receipt.intent_id.clone(), receipt)) + .collect::>(); + let mut statuses = cache + .get_all::()? + .into_iter() + .map(|intent| { + let receipt = receipts.remove(&intent.intent_id); + EpiphanyToolInvocationStatus { + intent_id: intent.intent_id, + adapter: intent.adapter, + server: intent.server, + tool_name: intent.tool_name, + caller: intent.caller, + reason: intent.reason, + created_at: intent.created_at, + status: receipt + .as_ref() + .map(|receipt| receipt.status.clone()) + .unwrap_or_else(|| "pending".to_string()), + receipt_id: receipt.as_ref().map(|receipt| receipt.receipt_id.clone()), + completed_at: receipt.as_ref().map(|receipt| receipt.completed_at.clone()), + error: receipt.and_then(|receipt| receipt.error), + } + }) + .collect::>(); + statuses.sort_by(|left, right| { + left.created_at + .cmp(&right.created_at) + .then_with(|| left.intent_id.cmp(&right.intent_id)) + }); + Ok(statuses) +} + pub fn runtime_hello_frame(store_path: impl AsRef) -> Result> { let mut cache = runtime_spine_cache(store_path.as_ref())?; cache.pull_all_backing_stores()?; @@ -2806,6 +2888,73 @@ mod tests { Ok(()) } + #[test] + fn runtime_spine_derives_tool_invocation_statuses() -> Result<()> { + let temp = tempdir()?; + let store = temp.path().join("runtime.msgpack"); + initialize_runtime_spine( + &store, + RuntimeSpineInitOptions { + runtime_id: "epiphany-test".to_string(), + display_name: "Epiphany Test".to_string(), + created_at: "2026-05-06T00:00:00Z".to_string(), + }, + )?; + let mut cache = runtime_spine_cache(&store)?; + cache.put( + "intent:done", + &EpiphanyToolInvocationIntent::new( + "done", + "codex-mcp", + "smoke-server", + "smoke_tool", + "{}", + "model-request-1", + "Test completed tool call.", + "2026-05-06T00:01:00Z", + ), + )?; + cache.put( + "intent:pending", + &EpiphanyToolInvocationIntent::new( + "pending", + "codex-mcp", + "smoke-server", + "waiting_tool", + "{}", + "model-request-2", + "Test pending tool call.", + "2026-05-06T00:02:00Z", + ), + )?; + let mut failed_receipt = EpiphanyToolInvocationReceipt::new( + "receipt-done", + "done", + "codex-mcp", + "smoke-server", + "smoke_tool", + "failed", + "2026-05-06T00:03:00Z", + ); + failed_receipt.error = Some("smoke server absent".to_string()); + cache.put("receipt:done", &failed_receipt)?; + + let status = runtime_spine_status(&store)?; + assert_eq!(status.tool_invocation_intents, 2); + assert_eq!(status.tool_invocation_receipts, 1); + assert_eq!(status.pending_tool_invocations, 1); + + let invocations = runtime_tool_invocation_statuses(&store)?; + assert_eq!(invocations.len(), 2); + assert_eq!(invocations[0].intent_id, "done"); + assert_eq!(invocations[0].status, "failed"); + assert_eq!(invocations[0].error.as_deref(), Some("smoke server absent")); + assert_eq!(invocations[1].intent_id, "pending"); + assert_eq!(invocations[1].status, "pending"); + assert!(invocations[1].receipt_id.is_none()); + Ok(()) + } + #[test] fn runtime_spine_opens_and_completes_native_jobs() -> Result<()> { let temp = tempdir()?; diff --git a/notes/fresh-workspace-handoff.md b/notes/fresh-workspace-handoff.md index c1d30833..86bdae2f 100644 --- a/notes/fresh-workspace-handoff.md +++ b/notes/fresh-workspace-handoff.md @@ -40,6 +40,7 @@ remembers doctrine; the branch remembers the blade. - `epiphany-model-runtime` is the current provider-neutral executable boundary. It is built by the `epiphany-openai-runtime` crate for now and accepts `--provider openai-codex`; the old `epiphany-openai-runtime` binary, `--openai-runtime-bin`, and `openai-runtime` executor name survive only as compatibility aliases. Coordinator run mode, local wrapper run mode, and repo birth runner should call `--model-runtime-bin` plus `--model-provider`. The typed request/event/receipt contract is now provider-neutral in `epiphany-model-adapter` as `epiphany.model_request.v0`, `epiphany.model_stream_event.v0`, `epiphany.model_receipt.v0`, and `epiphany.model_adapter_status.v0`; OpenAI/Codex documents are adapter evidence behind that boundary, not scheduler/status/state authority. - Coordinator plan/run passes now emit `epiphany.coordinator_run_receipt.v0` into runtime-spine. `coordinator-summary.json` and `coordinator-steps.jsonl` remain useful operator artifacts, but the durable receipt of what the coordinator decided is typed CultCache/CultNet state. - The first tool/MCP contract surface exists in `epiphany-tool-adapter`: `epiphany.tool_capability.v0`, `epiphany.tool_invocation_intent.v0`, and `epiphany.tool_invocation_receipt.v0`. Runtime-spine advertises these as the Epiphany-facing tool boundary. `epiphany-model-runtime` now materializes complete MCP-shaped model tool calls as typed invocation intents, and `epiphany-tool-codex-mcp-spine` is the quarantined executing adapter: it consumes one typed invocation intent from the mixed runtime-spine CultCache store, calls user-declared Codex MCP through `codex-mcp`, and emits a typed invocation receipt. Raw MCP JSON remains protocol-edge cargo; Codex MCP is transport scaffolding, not Epiphany state, prompt, scheduler, or policy authority. +- Native status now exposes that quarantined bridge spine without granting it authority. `runtime_spine_status` counts tool invocation intents, receipts, and pending calls; `runtime_tool_invocation_statuses` derives read-only intent/receipt status rows; `epiphany-runtime-spine status` reports the counts; and `epiphany-mvp-status --runtime-store ` renders the latest tool calls under `tools`. This is operator visibility only. The next clean backend slice is the typed tool-result feedback path into model continuation, with Epiphany-owned prompt/result policy and no Codex prompt machinery instructing Epiphany agents. - The active foundation directive is now `notes/codex-starvation-and-cultnet-liberation-plan.md`. The previous Codex app-server control-plane rebuild made Epiphany less rotten inside Codex, but that is not the destination. Epiphany must become a native CultCache/CultMesh/CultNet runtime while remaining an honest modified Codex-derived backend for subscription auth/model use. Codex should remain relatively vanilla and keep doing Codex things, including useful app-server and streaming bridge affordances, but it must not own Epiphany state, processes, prompts, scheduler decisions, or policy. The bridge handles interop; Codex and Epiphany do not get to rummage around in each other's organs. - `notes/epiphany-cultmesh-dreaming-roadmap.md` is the new concrete design for distributed Epiphany dreaming. The invariant is hard: private state stays local; public dreams are separately authored typed documents distributed through CultMesh/CultNet; foreign dreams are thought weather until a reviewed local adoption receipt digests them. The first code slice should be dream schemas plus a local CultMesh-backed store, not public fanout. - CultMesh is now the preferred Rust abstraction for that local store work. The compile-time Rust substrate is repo-contained: `vendor/cultcache-rs`, `vendor/cultnet-rs`, and `vendor/cultmesh-rs`. The old `E:\Projects\CultLib\crates\*` dependency body is dead in this checkout and must not be revived by accident. Vendored CultCache reads/writes `cultcache.store.v1`, so `state/ledgers.msgpack` and `epiphany-state status` are aligned again. The first integrations are deliberately small: status, Verse policy, global room policy, organ contract policy, native operator status, native operator snapshots, and local operator run intent/receipt round-trip through CultMesh. Use `cargo run --manifest-path .\epiphany-core\Cargo.toml --bin epiphany-cultmesh-smoke`, `cargo run --manifest-path .\epiphany-core\Cargo.toml --bin epiphany-cultmesh-status -- smoke --store .\.epiphany-smoke\cultmesh\operator-status.ccmp --runtime-id epiphany-cultmesh-status-smoke`, `cargo run --manifest-path .\epiphany-core\Cargo.toml --bin epiphany-operator-snapshot -- smoke --store .\.epiphany-smoke\cultmesh\operator-snapshots.ccmp --runtime-id epiphany-operator-snapshot-smoke --snapshot-id smoke-status`, and `cargo run --manifest-path .\epiphany-core\Cargo.toml --bin epiphany-operator-run -- smoke --store .\.epiphany-smoke\cultmesh\operator-runs.ccmp --runtime-id epiphany-operator-run-smoke --run-id smoke-run` for the focused proofs. Future local dream/status/Verse work should start from CultMesh, not raw CultNet, unless the task is polishing the CultMesh internals themselves. Preserve the three Verse tiers: `epiphany-internal` for private sub-agent typed state, `gamecult-local` for trusted LAN/Yggdrasil-tunnel GameCult sharing, and `epiphany-global` for untrusted public dreams plus topic-specific threaded public rooms for Face posts. @@ -182,7 +183,7 @@ remembers doctrine; the branch remembers the blade. - The planning loop is now runtime-backed and operator-visible. Typed captures, backlog items, roadmap streams, Objective Drafts, and GitHub issue source refs live in `EpiphanyThreadState`, validate through revision-gated `thread/epiphany/update`, render into prompts when present, project read-only through the `planning` view lens, render in the GUI Planning panel, can be synthesized by the fixed Imagination/planning lane, and can be explicitly adopted through the artifacted `adoptObjectiveDraft` GUI action. Chat is deliberation, not an objective pipe; ideas and GitHub Issues remain planning state until explicit human adoption. - The bridge/dashboard slice is now landed far enough to test locally. Native `epiphany-rider-bridge` inspects Rider installation, solution, VCS, changed files, and captures file/selection/symbol context into `.epiphany-gui/rider` artifacts; Aquarium has Inspect Rider and renders Rider audit artifacts in Environment; Aquarium also embeds the adjacent EpiphanyGraph viewer over typed `graphs.architecture`, `graphs.dataflow`, and `graphs.links`. - A first Rider plugin scaffold lives under `integrations/rider`: tool window, Refresh status, and Send Context to Epiphany action. It shells through native `epiphany-rider-bridge` and does not own state. `gradle` is not installed on this machine, so the scaffold is not build-verified yet. -- Next real move: continue Codex starvation and native Epiphany ownership. Quarantine Rider/Unity bridge work for now; those artifacts remain optional later environment evidence, not MVP blockers. Keep EpiphanyAgent focused on backend contracts, typed state, coordinator policy, heartbeat scheduling, Face guardrails, prompt-authority separation, and the ongoing purification from Python/JSON scaffolding into Rust/CultCache/CultMesh/CultNet organs. Resume repo birth/Aquarium/Rider/Unity work only when the user explicitly shifts priority back outward. GitHub Issues import is deferred until the backlog source is fresh enough to deserve Imagination's attention. +- Next real move: continue Codex starvation and native Epiphany ownership by wiring model-tool receipts back into typed model continuation. Quarantine Rider/Unity bridge work for now; those artifacts remain optional later environment evidence, not MVP blockers. Keep EpiphanyAgent focused on backend contracts, typed state, coordinator policy, heartbeat scheduling, Face guardrails, prompt-authority separation, and the ongoing purification from Python/JSON scaffolding into Rust/CultCache/CultMesh/CultNet organs. Resume repo birth/Aquarium/Rider/Unity work only when the user explicitly shifts priority back outward. GitHub Issues import is deferred until the backlog source is fresh enough to deserve Imagination's attention. - The repo is an Epiphany fork of Codex, not a Codex preset. - `vendor/codex` is tracked directly, not a submodule. - `epiphany-core` owns the heavy Epiphany organs where practical. diff --git a/state/ledgers.msgpack b/state/ledgers.msgpack index 60158d61141c2032db6d77286609ddc0cc5ea553..fe8e050b1e53986928e63feaa678cea4df838543 100644 GIT binary patch delta 300 zcmY+8F-`+95JmBJ=@7IjMxtI=Rso_=rVa`cqDW`#*X8d_T?h(!A;49^bbwKaM1u3c&@-W{RmVjYW`F!{BrXo+Sqlmgazqk~{)0 zOVq$b6ELG$Y^=Tp+ZwKD2g=yLvbi|N_MjRV>z08D98byBg~2*os7#iLi?m~ t0fYV!&YaO>Jd8CJe7yXZWAqK&{<=4oeo7Yz6*^OxZ^y{@!4*>B_7?;MY$5;v delta 46 zcmZp=#QFX_=LTU$0rL` renders a `tools` section without executing calls, accepting results, or letting Codex prompt machinery steer Epiphany agents. - The `roles` view lens is the harness-native role ownership surface: it projects implementation, Imagination/planning, modeling/checkpoint, verification/review, and reorientation lanes from authoritative typed state, bound jobs, pressure/reorient/CRRC, and worker result status without launching, scheduling, accepting, compacting, or mutating state. - `thread/epiphany/roleLaunch` and `thread/epiphany/roleResult` are the first explicit role-scoped specialist templates: Imagination/planning, modeling/checkpoint, and verification/review launch through fixed heartbeat-backed bindings with typed runtime-spine receipts and can be read back as reviewable findings from typed runtime-spine job results, while implementation stays owned by the main coding agent and reorientation stays on the CRRC-specific launch/result path. - `thread/epiphany/roleAccept` is the first review-gated role finding acceptance path: it accepts completed heartbeat-backed findings from typed runtime-spine results, accepts Imagination/planning findings only when they return a valid planning-only `statePatch` with draft Objective Draft review gates, accepts completed modeling/checkpoint findings only with a modeling-safe `statePatch`, builds accepted evidence/observation/receipt bundles through `epiphany-core`, and rejects verification, implementation, reorientation, job binding, objective adoption, or broad authority fields. @@ -550,4 +552,4 @@ current_status: materializes complete MCP-shaped model tool calls as typed tool invocation intents, and the Codex MCP spine can consume those intents from the mixed runtime-spine store and emit typed success/failure receipts. - next_action: Continue Codex starvation and CultNet liberation by deciding the next loop owner for tool results: either a bounded coordinator action that executes pending tool intents and feeds reviewed `ToolResult` input back into a follow-up model turn, or a narrower operator-visible pending-tool review surface first. + next_action: Continue Codex starvation and CultNet liberation by wiring typed tool invocation receipts back into model continuation through an Epiphany-owned policy path; the pending-tool operator visibility surface is landed, so the next fork is how follow-up model input is owned without Codex prompt machinery steering Epiphany agents.