diff --git a/epiphany-core/src/bin/epiphany-mvp-coordinator-smoke.rs b/epiphany-core/src/bin/epiphany-mvp-coordinator-smoke.rs index d5205a3b..0e9b003f 100644 --- a/epiphany-core/src/bin/epiphany-mvp-coordinator-smoke.rs +++ b/epiphany-core/src/bin/epiphany-mvp-coordinator-smoke.rs @@ -8,8 +8,6 @@ use std::fs; use std::path::{Path, PathBuf}; use std::process::Command; -const DEFAULT_APP_SERVER: &str = r"C:\Users\Meta\.cargo-target-codex\debug\codex-app-server.exe"; - fn main() -> Result<()> { let args = Args::parse()?; let result = run_smoke(&args)?; @@ -19,7 +17,6 @@ fn main() -> Result<()> { #[derive(Debug)] struct Args { - app_server: PathBuf, artifact_root: PathBuf, coordinator_exe: Option, } @@ -28,14 +25,15 @@ impl Args { fn parse() -> Result { let root = env::current_dir().context("failed to resolve current dir")?; let mut parsed = Self { - app_server: PathBuf::from(DEFAULT_APP_SERVER), artifact_root: root.join(".epiphany-dogfood").join("coordinator-smoke"), coordinator_exe: None, }; let mut args = env::args().skip(1); while let Some(arg) = args.next() { match arg.as_str() { - "--app-server" => parsed.app_server = take_path(&mut args, "--app-server")?, + "--app-server" => { + let _ = take_path(&mut args, "--app-server")?; + } "--artifact-root" => { parsed.artifact_root = take_path(&mut args, "--artifact-root")?; } @@ -51,14 +49,6 @@ impl Args { fn run_smoke(args: &Args) -> Result { let root = env::current_dir().context("failed to resolve current dir")?; - let app_server = absolute_path(&args.app_server)?; - ensure_default_app_server_built(&root, &app_server)?; - if !app_server.exists() { - return Err(anyhow!( - "codex app-server binary not found: {}", - app_server.display() - )); - } let artifact_root = absolute_path(&args.artifact_root)?; reset_artifact_root(&root, &artifact_root)?; let coordinator = match &args.coordinator_exe { @@ -72,7 +62,6 @@ fn run_smoke(args: &Args) -> Result { let cold = run_coordinator( &root, &coordinator, - &app_server, &artifact_root, RunOptions { name: "cold", @@ -95,7 +84,6 @@ fn run_smoke(args: &Args) -> Result { let local = run_coordinator( &root, &coordinator, - &app_server, &artifact_root, RunOptions { name: "local-bootstrap", @@ -118,7 +106,6 @@ fn run_smoke(args: &Args) -> Result { let pressure = run_coordinator( &root, &coordinator, - &app_server, &artifact_root, RunOptions { name: "pressure", @@ -149,7 +136,6 @@ fn run_smoke(args: &Args) -> Result { let hands_gate = run_coordinator( &root, &coordinator, - &app_server, &artifact_root, RunOptions { name: "hands-gate", @@ -233,7 +219,6 @@ struct RunOptions { fn run_coordinator( root: &Path, coordinator: &Path, - app_server: &Path, artifact_root: &Path, options: RunOptions, ) -> Result { @@ -241,8 +226,6 @@ fn run_coordinator( let mut command = Command::new(coordinator); command .current_dir(root) - .arg("--app-server") - .arg(app_server) .arg("--artifact-dir") .arg(&artifact_dir) .arg("--runtime-store") @@ -301,6 +284,13 @@ fn record_hands_pass(hands_action: &Path, summary: &Value) -> Result { let stderr_artifact = artifact_dir.join("hands-pass-command.stderr.log"); fs::write(&stdout_artifact, "hands pass smoke command output\n")?; fs::write(&stderr_artifact, "")?; + let commit = Command::new("git") + .args(["log", "-1", "--format=%H", "--", "tools/epiphany_local_run.ps1"]) + .output() + .context("failed to locate a real commit for the Hands smoke path")?; + require(commit.status.success(), "failed to resolve Hands smoke commit")?; + let commit_sha = String::from_utf8(commit.stdout)?.trim().to_string(); + require(!commit_sha.is_empty(), "Hands smoke path has no commit history")?; let output = Command::new(hands_action) .arg("--store") .arg(artifact_dir.join("runtime-spine.msgpack")) @@ -320,9 +310,9 @@ fn record_hands_pass(hands_action: &Path, summary: &Value) -> Result { .arg("--stderr-artifact") .arg(&stderr_artifact) .arg("--commit-sha") - .arg("dry-run-smoke") + .arg(commit_sha) .arg("--branch") - .arg("coordinator-smoke") + .arg("main") .output() .context("failed to run Hands action recorder")?; if !output.status.success() { @@ -348,8 +338,6 @@ fn require_artifacts(summary: &Value) -> Result<()> { "coordinator-final-status.json", "coordinator-final-status.txt", "coordinator-final-action.txt", - "epiphany-transcript.jsonl", - "epiphany-server.stderr.log", "agent-function-telemetry.json", "runtime-spine-status.json", ] { @@ -373,6 +361,14 @@ fn require_artifacts(summary: &Value) -> Result<()> { runtime_status["sessions"].as_u64().unwrap_or(0) >= 1, "native runtime spine should record a session", )?; + let telemetry: Value = serde_json::from_str(&fs::read_to_string( + artifact_dir.join("agent-function-telemetry.json"), + )?)?; + require( + telemetry["appServerCalls"].as_u64() == Some(0) + && telemetry["transport"].as_str() == Some("cultcache"), + "native coordinator telemetry must prove zero app-server calls", + )?; Ok(()) } @@ -454,40 +450,6 @@ fn ensure_epiphany_bin_built(root: &Path, binary: &Path, bin_name: &str) -> Resu ) } -fn ensure_default_app_server_built(root: &Path, app_server: &Path) -> Result<()> { - let default_app_server = PathBuf::from(DEFAULT_APP_SERVER); - if app_server != default_app_server { - return Ok(()); - } - if app_server.exists() { - return Ok(()); - } - let status = Command::new("cargo") - .current_dir(root) - .env("CARGO_TARGET_DIR", r"C:\Users\Meta\.cargo-target-codex") - .arg("build") - .arg("--manifest-path") - .arg( - root.join("vendor") - .join("codex") - .join("codex-rs") - .join("Cargo.toml"), - ) - .arg("-p") - .arg("codex-app-server") - .arg("--bin") - .arg("codex-app-server") - .status() - .context("failed to build default codex-app-server")?; - require( - status.success() && app_server.exists(), - &format!( - "default codex-app-server binary was not built: {}", - app_server.display() - ), - ) -} - fn absolute_path(path: &Path) -> Result { if path.is_absolute() { Ok(path.to_path_buf()) diff --git a/epiphany-core/src/bin/epiphany-mvp-coordinator.rs b/epiphany-core/src/bin/epiphany-mvp-coordinator.rs index 5f5db796..1a9555c6 100644 --- a/epiphany-core/src/bin/epiphany-mvp-coordinator.rs +++ b/epiphany-core/src/bin/epiphany-mvp-coordinator.rs @@ -50,7 +50,6 @@ const DETACHED_PROCESS: u32 = 0x0000_0008; #[path = "epiphany-mvp-status.rs"] mod status_cli; -const DEFAULT_APP_SERVER: &str = r"C:\Users\Meta\.cargo-target-codex\debug\codex-app-server.exe"; const DEFAULT_MODEL_RUNTIME_BIN: &str = "epiphany-model-runtime"; const DEFAULT_TOOL_ADAPTER_BIN: &str = "epiphany-tool-codex-mcp-spine"; const WORKER_AUTO_TOOL_MAX_ROUNDS: usize = 24; @@ -66,7 +65,6 @@ fn main() -> Result<()> { #[derive(Debug)] struct Args { - app_server: PathBuf, model_runtime_bin: PathBuf, tool_adapter_bin: PathBuf, model_provider: String, @@ -100,7 +98,6 @@ impl Args { let root = env::current_dir().context("failed to resolve current dir")?; let mut args = env::args().skip(1); let mut parsed = Args { - app_server: PathBuf::from(DEFAULT_APP_SERVER), model_runtime_bin: PathBuf::from(DEFAULT_MODEL_RUNTIME_BIN), tool_adapter_bin: PathBuf::from(DEFAULT_TOOL_ADAPTER_BIN), model_provider: "openai-codex".to_string(), @@ -135,7 +132,9 @@ impl Args { }; while let Some(arg) = args.next() { match arg.as_str() { - "--app-server" => parsed.app_server = take_path(&mut args, "--app-server")?, + "--app-server" => { + let _ = take_path(&mut args, "--app-server")?; + } "--model-runtime-bin" => { parsed.model_runtime_bin = take_path(&mut args, "--model-runtime-bin")?; } @@ -210,7 +209,6 @@ fn run_coordinator(args: &Args) -> Result { let root = env::current_dir().context("failed to resolve current dir")?; let local_verse_store = status_cli::absolute_path(&args.local_verse_store)?; assert_local_verse_brake_released(&local_verse_store, "epiphany-mvp-coordinator")?; - let app_server = status_cli::absolute_path(&args.app_server)?; let mut cwd = status_cli::absolute_path(&args.cwd)?; let model_runtime_bin = resolve_model_runtime_bin(&root, &args.model_runtime_bin)?; let tool_adapter_bin = resolve_model_runtime_bin(&root, &args.tool_adapter_bin)?; @@ -225,8 +223,6 @@ fn run_coordinator(args: &Args) -> Result { prepare_workspace(&cwd)?; } - let transcript_path = artifact_dir.join("epiphany-transcript.jsonl"); - let stderr_path = artifact_dir.join("epiphany-server.stderr.log"); let telemetry_path = artifact_dir.join("agent-function-telemetry.json"); let steps_path = artifact_dir.join("coordinator-steps.jsonl"); let mut steps = Vec::new(); @@ -235,39 +231,16 @@ fn run_coordinator(args: &Args) -> Result { let mut final_status = Value::Null; let mut final_action = Value::Null; - let mut client = status_cli::AppServerClient::start( - &app_server, - &codex_home, - &transcript_path, - &stderr_path, - )?; - client.send( - "initialize", - Some(json!({ - "clientInfo": { - "name": "epiphany-mvp-coordinator", - "title": "Epiphany MVP Coordinator", - "version": "0.1.0", - }, - "capabilities": {"experimentalApi": true}, - })), - true, - )?; - client.send("initialized", None, false)?; - - let thread_id = if let Some(thread_id) = &args.thread_id { - let resumed = client.send("thread/resume", Some(json!({"threadId": thread_id})), true)?; - startup_events.push(thread_lifecycle_event("threadResume", &resumed)); - thread_id.clone() - } else { - let started = client.send( - "thread/start", - Some(json!({"cwd": cwd, "ephemeral": args.ephemeral})), - true, - )?; - startup_events.push(thread_lifecycle_event("threadStart", &started)); - text_at(&started, &["thread", "id"])? - }; + let thread_id = args + .thread_id + .clone() + .unwrap_or_else(|| format!("epiphany-native-{}", Uuid::new_v4())); + startup_events.push(json!({ + "type": "nativeCoordinatorThread", + "threadId": thread_id, + "ephemeral": args.ephemeral, + "workspace": cwd, + })); let runtime_session_id = format!("coordinator-{thread_id}"); let runtime_identity = initialize_runtime_spine( &runtime_store, @@ -321,17 +294,8 @@ fn run_coordinator(args: &Args) -> Result { })); if args.bootstrap_smoke_state { - client.send( - "thread/epiphany/update", - Some(json!({"threadId": thread_id, "expectedRevision": 0, "patch": reorient_patch()})), - true, - )?; + apply_bootstrap_patch(&runtime_store, &thread_id, reorient_patch())?; if args.simulate_source_drift { - let _ = client.send( - "thread/epiphany/freshness", - Some(json!({"threadId": thread_id})), - true, - ); fs::write( cwd.join(WATCHED_RELATIVE_PATH), "pub fn reorient_target() -> &'static str {\n \"after\"\n}\n", @@ -339,14 +303,10 @@ fn run_coordinator(args: &Args) -> Result { thread::sleep(Duration::from_millis(500)); } } else if args.bootstrap_local_state { - client.send( - "thread/epiphany/update", - Some(json!({ - "threadId": thread_id, - "expectedRevision": 0, - "patch": local_mvp_checkpoint_patch(&cwd, args.bootstrap_objective.as_deref()), - })), - true, + apply_bootstrap_patch( + &runtime_store, + &thread_id, + local_mvp_checkpoint_patch(&cwd, args.bootstrap_objective.as_deref()), )?; } @@ -427,8 +387,13 @@ fn run_coordinator(args: &Args) -> Result { } if args.supersede_failed_results && role_result_needs_supersession(role_id, &result) { - let superseded = - supersede_role_result(&mut client, &thread_id, role_id, revision, &result)?; + let superseded = supersede_role_result( + &runtime_store, + &thread_id, + role_id, + revision, + &result, + )?; push_event( &mut step, json!({"type": "roleFailureReview", "roleId": role_id, "superseded": status_cli::sanitize_for_operator(superseded)}), @@ -572,8 +537,12 @@ fn run_coordinator(args: &Args) -> Result { } } "launchReorientWorker" => { - let launch = - launch_reorient(&mut client, &thread_id, revision, args.max_runtime_seconds)?; + let launch = launch_reorient( + &runtime_store, + &thread_id, + revision, + args.max_runtime_seconds, + )?; let worker_job_id = worker_job_id_from_launch(&launch)?; push_event( &mut step, @@ -655,10 +624,7 @@ fn run_coordinator(args: &Args) -> Result { "agent-function-telemetry.json".to_string(), "runtime-spine-status.json".to_string(), ]; - let sealed_artifact_manifest = vec![ - "epiphany-transcript.jsonl".to_string(), - "epiphany-server.stderr.log".to_string(), - ]; + let sealed_artifact_manifest = Vec::new(); let receipt_created_at = now(); let coordinator_run_receipt = EpiphanyCoordinatorRunReceipt { schema_version: COORDINATOR_RUN_RECEIPT_SCHEMA_VERSION.to_string(), @@ -699,7 +665,7 @@ fn run_coordinator(args: &Args) -> Result { }; put_coordinator_run_receipt(&runtime_store, &coordinator_run_receipt)?; let summary = json!({ - "objective": "Coordinate the Epiphany MVP lanes over existing app-server APIs.", + "objective": "Coordinate the Epiphany MVP lanes through native typed state and runtime organs.", "artifactDir": artifact_dir, "modelRuntimeBin": model_runtime_bin, "toolAdapterBin": tool_adapter_bin, @@ -722,10 +688,7 @@ fn run_coordinator(args: &Args) -> Result { "store": runtime_store, }, "artifactManifest": artifact_manifest, - "sealedArtifactManifest": [ - {"path": "epiphany-transcript.jsonl", "reason": "sealed JSON-RPC audit trail; do not read during normal supervision"}, - {"path": "epiphany-server.stderr.log", "reason": "sealed app-server diagnostics; inspect only for explicit debugging"} - ] + "sealedArtifactManifest": [] }); write_json(&artifact_dir.join("coordinator-summary.json"), &summary)?; write_json( @@ -747,7 +710,15 @@ fn run_coordinator(args: &Args) -> Result { serde_json::to_string_pretty(&summary["finalAction"])? ), )?; - status_cli::write_transcript_telemetry(&transcript_path, &telemetry_path)?; + write_json( + &telemetry_path, + &json!({ + "source": "epiphany-native-coordinator", + "transport": "cultcache", + "appServerCalls": 0, + "rawTextExposed": false, + }), + )?; Ok(summary) } @@ -787,6 +758,22 @@ fn collect_coordinator_status(runtime_store: &Path, thread_id: &str) -> Result Result { + let patch: epiphany_core::EpiphanyRoleStatePatchDocument = + serde_json::from_value(patch).context("failed to decode typed bootstrap state patch")?; + let service = epiphany_core::EpiphanyCoordinatorService::new(runtime_store, runtime_store); + let applied = service.apply_state_update( + thread_id, + epiphany_core::state_update_from_role_patch(Some(0), patch), + None, + )?; + Ok(json!({ + "revision": applied.revision, + "changedFields": applied.changed_fields.iter().map(|field| format!("{field:?}")).collect::>(), + "epiphanyState": applied.state, + })) +} fn resolve_model_runtime_bin(root: &Path, configured: &Path) -> Result { if configured.components().count() != 1 { return status_cli::absolute_path(configured); @@ -1148,7 +1135,7 @@ fn role_result_needs_supersession(role_id: &str, result: &Value) -> bool { } fn supersede_role_result( - client: &mut status_cli::AppServerClient, + runtime_store: &Path, thread_id: &str, role_id: &str, expected_revision: Option, @@ -1162,27 +1149,35 @@ fn supersede_role_result( .unwrap_or_else(|| default_binding_id_for_role(role_id)); let summary = first_string_at(result, &[&["finding", "summary"], &["note"]]) .unwrap_or_else(|| "Role result reviewed and superseded.".to_string()); - let receipt = json!({ - "id": format!("role-failure-review-{}", Uuid::new_v4()), - "result_id": result_id, - "job_id": job_id, - "binding_id": binding_id, - "surface": "roleFailureReview", - "role_id": role_id, - "status": "superseded", - "accepted_at": now(), - "summary": summary, - }); - let mut payload = json!({ - "threadId": thread_id, - "patch": { - "acceptanceReceipts": [receipt], + let receipt = epiphany_state_model::EpiphanyAcceptanceReceipt { + id: format!("role-failure-review-{}", Uuid::new_v4()), + result_id, + job_id, + binding_id, + surface: "roleFailureReview".to_string(), + role_id: role_id.to_string(), + status: "superseded".to_string(), + accepted_at: now(), + accepted_observation_id: None, + accepted_evidence_id: None, + summary: Some(summary), + }; + let service = epiphany_core::EpiphanyCoordinatorService::new(runtime_store, runtime_store); + let applied = service.apply_state_update( + thread_id, + epiphany_core::EpiphanyStateUpdate { + expected_revision: expected_revision.and_then(|value| u64::try_from(value).ok()), + acceptance_receipts: vec![receipt.clone()], + ..Default::default() }, - }); - if let Some(revision) = expected_revision { - payload["expectedRevision"] = json!(revision); - } - client.send("thread/epiphany/update", Some(payload), true) + None, + )?; + Ok(json!({ + "revision": applied.revision, + "changedFields": applied.changed_fields.iter().map(|field| format!("{field:?}")).collect::>(), + "epiphanyState": applied.state, + "receipt": receipt, + })) } fn default_binding_id_for_role(role_id: &str) -> String { @@ -1196,16 +1191,55 @@ fn default_binding_id_for_role(role_id: &str) -> String { } fn launch_reorient( - client: &mut status_cli::AppServerClient, + runtime_store: &Path, thread_id: &str, expected_revision: Option, max_runtime_seconds: u64, ) -> Result { - let mut payload = json!({"threadId": thread_id, "maxRuntimeSeconds": max_runtime_seconds}); - if let Some(revision) = expected_revision { - payload["expectedRevision"] = json!(revision); - } - client.send("thread/epiphany/reorientLaunch", Some(payload), true) + let service = epiphany_core::EpiphanyCoordinatorService::new(runtime_store, runtime_store); + let state = service + .state()? + .ok_or_else(|| anyhow!("cannot launch reorientation without native coordinator state"))?; + let checkpoint = state + .investigation_checkpoint + .as_ref() + .ok_or_else(|| anyhow!("cannot launch reorientation without a durable checkpoint"))?; + let status = collect_coordinator_status(runtime_store, thread_id)?; + let decision: epiphany_core::EpiphanyReorientDecision = + serde_json::from_value(status["reorient"]["decision"].clone()) + .context("native reorientation status did not contain a typed decision")?; + let context = epiphany_core::render_launch_dynamic_prompt_context( + runtime_store, + &state, + epiphany_core::reorient_launch_context_focus(&state, &decision.next_action), + ) + .map_err(anyhow::Error::msg)?; + let expected_revision = expected_revision.and_then(|value| u64::try_from(value).ok()); + let request = epiphany_core::build_epiphany_reorient_launch_request_with_dynamic_context( + thread_id, + expected_revision, + Some(max_runtime_seconds), + &state, + checkpoint, + &decision, + Some(context), + ); + let launched = service.launch_job( + thread_id, + &state, + &request, + format!("epiphany-heartbeat-launch-{}", Uuid::new_v4()), + Uuid::new_v4().to_string(), + now(), + )?; + Ok(json!({ + "bindingId": launched.binding_id, + "launcherJobId": launched.launcher_job_id, + "backendJobId": launched.backend_job_id, + "revision": launched.epiphany_state.revision, + "epiphanyState": launched.epiphany_state, + "decision": decision, + })) } fn worker_job_id_from_launch(launch: &Value) -> Result { @@ -1684,16 +1718,6 @@ fn state_revision(status: &Value) -> Option { }) } -fn thread_lifecycle_event(kind: &str, response: &Value) -> Value { - json!({ - "type": kind, - "threadId": response.pointer("/thread/id"), - "status": response.pointer("/thread/status"), - "cwd": response.pointer("/thread/cwd"), - "ephemeral": response.pointer("/thread/ephemeral"), - }) -} - fn push_event(step: &mut Value, event: Value) { step["events"].as_array_mut().unwrap().push(event); } @@ -1741,17 +1765,6 @@ fn append_operator_step_jsonl(path: &Path, step: &Value) -> Result<()> { append_jsonl(path, &status_cli::sanitize_for_operator(step.clone())) } -fn text_at(value: &Value, path: &[&str]) -> Result { - let mut cursor = value; - for key in path { - cursor = &cursor[*key]; - } - cursor - .as_str() - .map(ToString::to_string) - .ok_or_else(|| anyhow!("missing string at {}", path.join("."))) -} - fn take_string(args: &mut impl Iterator, name: &str) -> Result { args.next() .ok_or_else(|| anyhow!("{name} requires a value")) @@ -1772,6 +1785,18 @@ fn home_dir() -> PathBuf { mod tests { use super::*; + #[test] + fn coordinator_binary_has_no_codex_host_or_epiphany_json_rpc_dependency() { + let source = include_str!("epiphany-mvp-coordinator.rs"); + let production = source.split("#[cfg(test)]").next().unwrap_or(source); + for forbidden in ["AppServerClient", "thread/epiphany/", "codex-app-server"] { + assert!( + !production.contains(forbidden), + "native coordinator regrew host dependency {forbidden:?}" + ); + } + } + #[test] fn coordinator_status_and_result_reads_are_native() { let source = include_str!("epiphany-mvp-coordinator.rs"); diff --git a/epiphany-core/src/bin/epiphany-mvp-status.rs b/epiphany-core/src/bin/epiphany-mvp-status.rs index fcd0d8ce..37f156bf 100644 --- a/epiphany-core/src/bin/epiphany-mvp-status.rs +++ b/epiphany-core/src/bin/epiphany-mvp-status.rs @@ -37,7 +37,7 @@ use epiphany_core::derive_pressure_view; use epiphany_core::derive_role_board; use epiphany_core::derive_scene; use epiphany_core::interpret_runtime_role_worker_result; -use epiphany_core::load_thread_state_entry; +use epiphany_core::read_accepted_coordinator_state; use epiphany_core::recommend_crrc_action; use epiphany_core::recommend_reorientation; use epiphany_core::runtime_job_snapshot; @@ -253,8 +253,8 @@ 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) + let state = if store_path.exists() { + read_accepted_coordinator_state(&store_path) .with_context(|| format!("failed to load {}", store_path.display()))? } else { None @@ -262,13 +262,7 @@ fn run_native_status(args: &Args) -> Result { let thread_id = args .thread_id .clone() - .or_else(|| state_entry.as_ref().map(|entry| entry.thread_id.clone())) .unwrap_or_else(|| "native-local".to_string()); - let state = state_entry - .as_ref() - .map(|entry| entry.state()) - .transpose() - .context("failed to decode native Epiphany thread state")?; let state_ref = state.as_ref(); let loaded = state_ref.is_some(); @@ -1801,11 +1795,16 @@ pub fn write_transcript_telemetry(transcript: &Path, output: &Path) -> Result<() } pub fn native_json(bin_name: &str, args: &[&str]) -> Result { - let exe = PathBuf::from( + let sibling = env::current_exe() + .ok() + .and_then(|path| path.parent().map(Path::to_path_buf)) + .map(|path| path.join(format!("{bin_name}.exe"))); + let configured = PathBuf::from( env::var("CARGO_TARGET_DIR").unwrap_or_else(|_| DEFAULT_CARGO_TARGET_DIR.to_string()), ) .join("debug") .join(format!("{bin_name}.exe")); + let exe = sibling.filter(|path| path.exists()).unwrap_or(configured); let output = if exe.exists() { Command::new(&exe).args(args).output() } else { diff --git a/epiphany-core/src/coordinator_acceptance.rs b/epiphany-core/src/coordinator_acceptance.rs index bbc9bd77..116bfd29 100644 --- a/epiphany-core/src/coordinator_acceptance.rs +++ b/epiphany-core/src/coordinator_acceptance.rs @@ -464,7 +464,6 @@ pub fn reorient_acceptance_claimed_effects() -> Vec { pub fn coordinator_acceptance_cache(store_path: &Path) -> anyhow::Result { let mut cache = runtime_spine_cache(store_path)?; - cache.register_entry_type::()?; cache.pull_all_backing_stores()?; Ok(cache) } @@ -706,6 +705,13 @@ fn state_update_from_patch( } } +pub fn state_update_from_role_patch( + expected_revision: Option, + patch: EpiphanyRoleStatePatchDocument, +) -> EpiphanyStateUpdate { + state_update_from_patch(expected_revision, patch) +} + fn changed_fields_from_patch( patch: &EpiphanyRoleStatePatchDocument, ) -> Vec { diff --git a/epiphany-core/src/coordinator_state.rs b/epiphany-core/src/coordinator_state.rs index 0cefe6e3..1f835de0 100644 --- a/epiphany-core/src/coordinator_state.rs +++ b/epiphany-core/src/coordinator_state.rs @@ -1,9 +1,11 @@ use crate::EpiphanyStateUpdate; use crate::EpiphanyStateUpdatedField; +use crate::EpiphanyThreadStateEntry; +use crate::THREAD_STATE_KEY; use crate::apply_epiphany_state_update; +use crate::coordinator_acceptance_cache; use crate::epiphany_state_update_validation_errors; -use crate::load_thread_state; -use crate::write_thread_state; +use crate::read_accepted_coordinator_state; use anyhow::Result; use anyhow::anyhow; use epiphany_state_model::EpiphanyThreadState; @@ -17,7 +19,7 @@ pub struct EpiphanyCoordinatorStateApplied { } pub fn read_coordinator_state(store: &Path) -> Result> { - load_thread_state(store) + read_accepted_coordinator_state(store) } pub fn apply_coordinator_state_update( @@ -32,7 +34,9 @@ pub fn apply_coordinator_state_update( update, reference_turn_id, )?; - write_thread_state(store, thread_id, &state)?; + let mut cache = coordinator_acceptance_cache(store)?; + let entry = EpiphanyThreadStateEntry::from_state(thread_id, &state)?; + cache.put(THREAD_STATE_KEY, &entry)?; Ok(EpiphanyCoordinatorStateApplied { revision: state.revision, changed_fields, diff --git a/epiphany-core/src/lib.rs b/epiphany-core/src/lib.rs index 76aa262d..648e6776 100644 --- a/epiphany-core/src/lib.rs +++ b/epiphany-core/src/lib.rs @@ -145,6 +145,7 @@ pub use coordinator_acceptance::read_accepted_coordinator_state; pub use coordinator_acceptance::reorient_acceptance_claimed_effects; pub use coordinator_acceptance::role_acceptance_claimed_effects; pub use coordinator_acceptance::role_acceptance_enforceable_receipts; +pub use coordinator_acceptance::state_update_from_role_patch; pub use coordinator_launch::EpiphanyCoordinatorJobLaunchPlan; pub use coordinator_launch::commit_coordinator_job_launch; pub use coordinator_launch::plan_coordinator_job_launch; diff --git a/epiphany-core/src/runtime_spine.rs b/epiphany-core/src/runtime_spine.rs index 1e9b273e..08f01b55 100644 --- a/epiphany-core/src/runtime_spine.rs +++ b/epiphany-core/src/runtime_spine.rs @@ -711,6 +711,7 @@ pub struct EpiphanyRuntimeJobSnapshot { pub fn runtime_spine_cache(store_path: impl AsRef) -> Result { let store_path = store_path.as_ref(); let mut cache = CultCache::new(); + cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; diff --git a/notes/fresh-workspace-handoff.md b/notes/fresh-workspace-handoff.md index 32ea4fbd..19a15112 100644 --- a/notes/fresh-workspace-handoff.md +++ b/notes/fresh-workspace-handoff.md @@ -1861,9 +1861,20 @@ Codex view/result calls were deleted and a source test rejects AppServerClient o Verse/memory context, appends Verification Hands evidence or Modeling work-loop telemetry, builds the typed request, and calls the atomic service launch. `accept_role` calls the service acceptance actuator directly. A source test -guards every required context seam and rejects AppServerClient/routes. Five -production routes remain: bootstrap update/freshness, supersession update, and -reorientation launch. +guards every required context seam and rejects AppServerClient/routes. + +The coordinator liberation cut is now complete at runtime. Reorientation launch, +bootstrap, and supersession use typed native service operations; the binary +starts no app-server and contains no production Epiphany JSON-RPC route. Native +status and runtime caches now share the heterogeneous state/runtime schema, and +native binary lookup prefers the current executable's siblings instead of a +stale global Cargo target. `epiphany-mvp-coordinator-smoke` no longer builds or +requires codex-app-server; live proof at +`.epiphany-dogfood/native-coordinator-liberation` passed cold, local-bootstrap, +pressure, Hands gate, and real historical commit receipt checks with telemetry +`appServerCalls=0`. The next visible lie is role-board `authorityScopes` still +naming old `thread/epiphany/*` methods; replace them with native/CultNet typed +capability identifiers. ## Immediate Re-entry Instruction diff --git a/notes/native-coordinator-liberation-map.md b/notes/native-coordinator-liberation-map.md index 43eb4e56..7f345528 100644 --- a/notes/native-coordinator-liberation-map.md +++ b/notes/native-coordinator-liberation-map.md @@ -244,5 +244,17 @@ Role mutation has now crossed too. `epiphany-mvp-coordinator` builds role launch requests from native state plus the full native Verse/memory/work-loop context, publishes them through `EpiphanyCoordinatorService::launch_job`, and dispatches auto-review through `accept_role`. The role launch and role acceptance routes -are gone. Bootstrap/freshness, supersession update, and reorientation launch are -the five remaining production route strings. +are gone. + +`epiphany-mvp-coordinator` is now fully native. Reorientation launch consumes +the typed native status decision, preserves native prompt context, and uses the +same atomic launch actuator. Bootstrap and supersession use typed state updates. +The binary starts no app-server, contains no production `thread/epiphany/*` +strings, and emits telemetry with `appServerCalls=0`. Its smoke harness no +longer builds or requires codex-app-server and passes cold, local bootstrap, +pressure, Hands gate, and real commit-receipt scenarios. + +The live output still advertises old JSON-RPC method names in role-board +`authorityScopes`. Those strings are presentation residue, not callable +coordinator authority, but they now lie about the native body and must be +replaced by typed native/CultNet capability identifiers. diff --git a/state/ledgers.msgpack b/state/ledgers.msgpack index 2e4e0b80..8eb12622 100644 Binary files a/state/ledgers.msgpack and b/state/ledgers.msgpack differ diff --git a/state/map.yaml b/state/map.yaml index 1f745248..f0877927 100644 --- a/state/map.yaml +++ b/state/map.yaml @@ -659,4 +659,4 @@ current_status: - Service lifecycle receipt history is now event-only: `load_epiphany_cultmesh_daemon_service_lifecycle_receipts` filters out the `epiphany-local/daemon-service-lifecycle-receipt/latest` mirror, while `load_latest_epiphany_cultmesh_daemon_service_lifecycle_receipt` remains the latest-state reader. Focused unit test `service_lifecycle_receipt_history_excludes_latest_mirror` proves two per-receipt writes return exactly two history records and latest points at the second. Fresh smoke `verse-query-lifecycle-history-filter-smoke` and live overview/triage `local-20260618-145632-497-efac6f0d` / `local-20260618-145632-321-867947af` prove compact swarm sights still expose service lifecycle attention plus the present elevated runbook artifact without daemon pokes or service mutation. Do not use a broad unscoped cargo test filter for this check on Windows; it fans out across bin harnesses and hit a broken pipe during this pass. - `epiphany-verse-query seed-compact` is the compact seed receipt for wrappers and read-only rites. The older `seed` command still prints the full local Verse context for explicit debugging, but compact wrapper modes now avoid full `seed`/final `query` readback after the combined overview proof exposed Windows debug stack overflow from full-context serialization pressure. last_completed_repo_swarm_cut: Huginn live-fire has crossed the first real repo Body from Persona pressure to branch-local Hands commit and Soul/Mind closure, and now has repeatable closure and redacted-public-proof mouths. On `E:\Projects\Huginn` branch `epiphany/huginn/first-awakening`, `tools/epiphany_local_run.ps1 -Mode repo-persona-intake` accepted item `huginn-inspection-readback-livefire`, Weksa/Persona intake remained sealed, and `epiphany-work derive-plan` lowered it to model-authored safe family `repo.status_section` for `README.md` only. `tools/epiphany_local_run.ps1 -Mode repo-swarm-run` advanced four bounded pulses: run-from-plan, adopt-from-plan, execute-from-plan, and close-from-execute. Huginn commit `e9b07c38fceabbdc89ea35c2156326c80c0393a2` updated only `README.md`; closure receipt `.epiphany\work\work-close-huginn-inspection-readback-livefire.json` records status `closed`, Soul verdict `passed`, Mind state commit `repo-work-close-huginn-inspection-readback-livefire-mind-commit`, safe family `repo.status_section`, path scope `README.md`, Bifrost publication gate, and `privateStateExposed=false`. Verification also ran Huginn's TypeScript compiler through concrete Node path: `C:\Program Files\nodejs\node.exe E:\Projects\Huginn\node_modules\typescript\bin\tsc -p tsconfig.json` passed. Native verifier `epiphany-repo-livefire-closure-smoke --workspace E:\Projects\Huginn --item huginn-inspection-readback-livefire --expected-path README.md --expected-family repo.status_section --expected-gate awaiting-publication --expected-blocker bifrost-publication-missing` checks closure receipt, Mind map entry, overview gate/blocker, authority seals, and `git show` changed paths, returning `status=ok`, `soulVerdict=passed`, `publicationGate=Bifrost`, and `privateStateExposed=false`. Wrapper `tools/epiphany_local_run.ps1 -Mode repo-livefire-closure -Workspace E:\Projects\Huginn -RepoWorkItem huginn-inspection-readback-livefire -SkipBuild` exposes the same read-only proof through the local operator mouth; artifact `local-20260621-190156-803-2f85ba15` printed commit, path, gate, blocker, Soul verdict, Mind commit receipt, and `privateStateExposed=False` without push, merge, publication, or target mutation. New wrapper `tools/epiphany_local_run.ps1 -Mode repo-work-public-proof -Workspace E:\Projects\Huginn -RepoWorkItem huginn-inspection-readback-livefire -SkipBuild` exports the redacted proof bundle and repo-local Verse index without publishing; artifact `local-20260621-190645-345-4555b1dc` wrote `.epiphany\public\proof-bundles\repo-work-public-proof-huginn-inspection-readback-livefire.json`, proof id `repo-work-public-proof-huginn-inspection-readback-livefire`, SHA-256 `857545b199f3e37eb06c2e757e5cfc201958e46667bb1f8403fd333a22620f63`, nine artifact rows, zero publication rows, and `privateStateExposed=False`. Gjallar readback `local-20260621-190701-140-b9519ec6` sees the `REPO-WORK-PUBLIC-PROOF` row and action row from Huginn's repo-local Verse with the same SHA-256 while Bifrost publication remains missing. Launcher compact modes are now named compact operator-context modes instead of read-only modes, and `bifrost-public-proof` summaries print item, target public Verse, room, proof SHA-256, review receipts, and credit receipts so publication receipts are auditable without claiming upstream sync. - next_action: Replace the five remaining `epiphany-mvp-coordinator` mutation routes: bootstrap update/freshness, failure supersession update, and reorientation launch. Status/results plus role launch/acceptance are native and preserve full Verse/memory/work-loop context. Remove AppServerClient startup after these final routes are cut. + next_action: Purge stale `thread/epiphany/*` authority labels from native role-board/status projections and replace them with typed native/CultNet capability identifiers. `epiphany-mvp-coordinator` itself is fully native, starts no app-server, has zero production route strings, and passes its multi-scenario smoke with `appServerCalls=0`.