diff --git a/epiphany-core/src/bin/epiphany-daemon-supervisor.rs b/epiphany-core/src/bin/epiphany-daemon-supervisor.rs index 5541dc89..8ae75b2a 100644 --- a/epiphany-core/src/bin/epiphany-daemon-supervisor.rs +++ b/epiphany-core/src/bin/epiphany-daemon-supervisor.rs @@ -225,6 +225,22 @@ fn service_launch(args: Args) -> Result<()> { )?; let context = query_epiphany_local_verse_context(&args.store, args.runtime_id.clone())?; assert_swarm_brake_allows_service_lifecycle(&context)?; + if !args.required_document_types.is_empty() + && (!args.schema_preflight_passed + || args.executable_sha256.as_deref().is_none_or(str::is_empty) + || args + .schema_catalog_sha256 + .as_deref() + .is_none_or(str::is_empty) + || args + .preflight_witness_id + .as_deref() + .is_none_or(str::is_empty)) + { + anyhow::bail!( + "typed service launch requires passing schema preflight, executable and schema SHA-256 fingerprints, and preflight witness identity" + ); + } let started_at = Utc::now(); let command_path = service_command_path(&args)?; let service_args = service_serve_args(&args); @@ -303,6 +319,11 @@ fn service_launch(args: Args) -> Result<()> { "exitCode": written.exit_code, "stdoutArtifact": args.stdout_artifact, "stderrArtifact": args.stderr_artifact, + "executableSha256": written.executable_sha256, + "schemaCatalogSha256": written.schema_catalog_sha256, + "preflightWitnessId": written.preflight_witness_id, + "requiredDocumentTypes": written.required_document_types, + "schemaPreflightPassed": written.schema_preflight_passed, "privateStateExposed": written.private_state_exposed, }))? ); @@ -3036,6 +3057,11 @@ fn service_lifecycle_receipt( "The service command may run the supervisor serve loop, but scheduler decisions remain typed local Verse receipts." .to_string(), ], + executable_sha256: args.executable_sha256.clone().unwrap_or_default(), + schema_catalog_sha256: args.schema_catalog_sha256.clone().unwrap_or_default(), + preflight_witness_id: args.preflight_witness_id.clone().unwrap_or_default(), + required_document_types: args.required_document_types.clone(), + schema_preflight_passed: args.schema_preflight_passed, } } @@ -3191,6 +3217,11 @@ struct Args { artifact_ref: Option, stdout_artifact: Option, stderr_artifact: Option, + executable_sha256: Option, + schema_catalog_sha256: Option, + preflight_witness_id: Option, + required_document_types: Vec, + schema_preflight_passed: bool, } impl Args { @@ -3233,6 +3264,11 @@ impl Args { let mut artifact_ref = None; let mut stdout_artifact = None; let mut stderr_artifact = None; + let mut executable_sha256 = None; + let mut schema_catalog_sha256 = None; + let mut preflight_witness_id = None; + let mut required_document_types = Vec::new(); + let mut schema_preflight_passed = false; while let Some(arg) = values.next() { match arg.as_str() { @@ -3372,6 +3408,30 @@ impl Args { values.next().context("missing --stderr-artifact value")?, )); } + "--executable-sha256" => { + executable_sha256 = + Some(values.next().context("missing --executable-sha256 value")?); + } + "--schema-catalog-sha256" => { + schema_catalog_sha256 = Some( + values + .next() + .context("missing --schema-catalog-sha256 value")?, + ); + } + "--preflight-witness-id" => { + preflight_witness_id = Some( + values + .next() + .context("missing --preflight-witness-id value")?, + ); + } + "--required-document-type" => required_document_types.push( + values + .next() + .context("missing --required-document-type value")?, + ), + "--schema-preflight-passed" => schema_preflight_passed = true, other => anyhow::bail!("unknown argument {other:?}"), } } @@ -3499,6 +3559,11 @@ impl Args { artifact_ref, stdout_artifact, stderr_artifact, + executable_sha256, + schema_catalog_sha256, + preflight_witness_id, + required_document_types, + schema_preflight_passed, }) } } diff --git a/epiphany-core/src/bin/epiphany-verse-query.rs b/epiphany-core/src/bin/epiphany-verse-query.rs index 9a5834a2..4b5bb616 100644 --- a/epiphany-core/src/bin/epiphany-verse-query.rs +++ b/epiphany-core/src/bin/epiphany-verse-query.rs @@ -3372,6 +3372,11 @@ fn run_cli() -> Result<()> { "Synthetic verse-query smoke receipt for service lifecycle action rows." .to_string(), ], + executable_sha256: String::new(), + preflight_witness_id: String::new(), + required_document_types: Vec::new(), + schema_preflight_passed: false, + schema_catalog_sha256: String::new(), }, )?; } @@ -3402,6 +3407,11 @@ fn run_cli() -> Result<()> { "Synthetic verse-query smoke receipt for single-service execution runbook action row." .to_string(), ], + executable_sha256: String::new(), + preflight_witness_id: String::new(), + required_document_types: Vec::new(), + schema_preflight_passed: false, + schema_catalog_sha256: String::new(), }, )?; write_epiphany_cultmesh_daemon_service_lifecycle_receipt( @@ -3432,6 +3442,11 @@ fn run_cli() -> Result<()> { "Synthetic verse-query smoke receipt for single-service lifecycle action rows." .to_string(), ], + executable_sha256: String::new(), + preflight_witness_id: String::new(), + required_document_types: Vec::new(), + schema_preflight_passed: false, + schema_catalog_sha256: String::new(), }, )?; let service_overview = load_swarm_overview_report(&args)?; @@ -3848,6 +3863,11 @@ fn run_cli() -> Result<()> { "Synthetic verse-query smoke receipt for lifecycle follow-up routing." .to_string(), ], + executable_sha256: String::new(), + preflight_witness_id: String::new(), + required_document_types: Vec::new(), + schema_preflight_passed: false, + schema_catalog_sha256: String::new(), }; let readiness_follow_up_row = receipt_directory_service_lifecycle_row( "cluster-service-lifecycle", diff --git a/epiphany-core/src/bin/epiphany-work.rs b/epiphany-core/src/bin/epiphany-work.rs index 42f07029..4c972a72 100644 --- a/epiphany-core/src/bin/epiphany-work.rs +++ b/epiphany-core/src/bin/epiphany-work.rs @@ -14454,6 +14454,53 @@ fn launch_repo_work_modeling_worker( )), }, ); + let runtime_bin = resolve_repo_work_model_runtime(epiphany_root)?; + let supervisor_bin = resolve_daemon_supervisor(epiphany_root)?; + let required_document_types = [ + epiphany_core::REPO_WORK_MODELING_ROUTE_TYPE, + epiphany_core::REPO_WORK_MODELING_REQUEST_TYPE, + epiphany_core::REPO_WORK_MODELING_FINDING_TYPE, + epiphany_core::RUNTIME_WORKER_LAUNCH_REQUEST_TYPE, + ]; + let mut preflight_command = Command::new(&runtime_bin); + preflight_command + .arg("preflight") + .arg("--store") + .arg(runtime_store); + for document_type in required_document_types { + preflight_command + .arg("--require-document-type") + .arg(document_type); + } + let preflight_output = preflight_command.output().with_context(|| { + format!( + "failed to preflight Modeling runtime {}", + runtime_bin.display() + ) + })?; + if !preflight_output.status.success() { + return Err(anyhow!( + "Modeling runtime preflight refused launch before opening a job: {}", + String::from_utf8_lossy(&preflight_output.stderr) + )); + } + let preflight: Value = serde_json::from_slice(&preflight_output.stdout) + .context("Modeling runtime preflight did not emit JSON")?; + if preflight["schemaPreflightPassed"].as_bool() != Some(true) { + return Err(anyhow!("Modeling runtime schema preflight did not pass")); + } + let executable_sha256 = preflight["executableSha256"] + .as_str() + .filter(|value| !value.is_empty()) + .ok_or_else(|| anyhow!("Modeling runtime preflight omitted executable SHA-256"))?; + let schema_catalog_sha256 = preflight["schemaCatalogSha256"] + .as_str() + .filter(|value| !value.is_empty()) + .ok_or_else(|| anyhow!("Modeling runtime preflight omitted schema catalog SHA-256"))?; + let preflight_witness_id = preflight["preflightWitnessId"] + .as_str() + .filter(|value| !value.is_empty()) + .ok_or_else(|| anyhow!("Modeling runtime preflight omitted witness identity"))?; let created_at = Utc::now().to_rfc3339_opts(chrono::SecondsFormat::Secs, true); open_runtime_spine_heartbeat_job( runtime_store, @@ -14480,8 +14527,6 @@ fn launch_repo_work_modeling_worker( created_at, }, )?; - let runtime_bin = resolve_repo_work_model_runtime(epiphany_root)?; - let supervisor_bin = resolve_daemon_supervisor(epiphany_root)?; let stdout_path = artifact_dir.join(format!("{job_id}.stdout.log")); let stderr_path = artifact_dir.join(format!("{job_id}.stderr.log")); let service_id = format!("idunn-{job_id}"); @@ -14521,6 +14566,21 @@ fn launch_repo_work_modeling_worker( .arg(&stdout_path) .arg("--stderr-artifact") .arg(&stderr_path) + .arg("--executable-sha256") + .arg(executable_sha256) + .arg("--schema-catalog-sha256") + .arg(schema_catalog_sha256) + .arg("--preflight-witness-id") + .arg(preflight_witness_id) + .arg("--required-document-type") + .arg(epiphany_core::REPO_WORK_MODELING_ROUTE_TYPE) + .arg("--required-document-type") + .arg(epiphany_core::REPO_WORK_MODELING_REQUEST_TYPE) + .arg("--required-document-type") + .arg(epiphany_core::REPO_WORK_MODELING_FINDING_TYPE) + .arg("--required-document-type") + .arg(epiphany_core::RUNTIME_WORKER_LAUNCH_REQUEST_TYPE) + .arg("--schema-preflight-passed") .arg("--reason") .arg(format!( "Idunn launches typed repo-work Modeling job {job_id}." @@ -14548,6 +14608,11 @@ fn launch_repo_work_modeling_worker( "lifecycleOwner": "Idunn", "lifecycleReceiptId": lifecycle["receiptId"], "serviceId": lifecycle["serviceId"], + "executableSha256": lifecycle["executableSha256"], + "schemaCatalogSha256": lifecycle["schemaCatalogSha256"], + "preflightWitnessId": lifecycle["preflightWitnessId"], + "requiredDocumentTypes": lifecycle["requiredDocumentTypes"], + "schemaPreflightPassed": lifecycle["schemaPreflightPassed"], "stdoutArtifact": stdout_path, "stderrArtifact": stderr_path, "requestId": request.request_id, @@ -16867,6 +16932,11 @@ mod authority_tests { assert!(!production.contains(".spawn()")); assert!(production.contains("epiphany-daemon-supervisor")); assert!(production.contains("\"lifecycleOwner\": \"Idunn\"")); + assert!( + production.find("preflight_command.output()") + < production.find("open_runtime_spine_heartbeat_job(") + ); + assert!(production.contains("schemaPreflightPassed")); assert!(!source.contains(&["RepoWork", "MapStore"].concat())); assert!(!source.contains(&["repo-work-map", ".msgpack"].concat())); } diff --git a/epiphany-core/src/cultmesh_integration.rs b/epiphany-core/src/cultmesh_integration.rs index f56e463a..1e14296d 100644 --- a/epiphany-core/src/cultmesh_integration.rs +++ b/epiphany-core/src/cultmesh_integration.rs @@ -1459,6 +1459,16 @@ pub struct EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry { pub private_state_exposed: bool, #[cultcache(key = 17)] pub notes: Vec, + #[cultcache(key = 18, default)] + pub executable_sha256: String, + #[cultcache(key = 19, default)] + pub preflight_witness_id: String, + #[cultcache(key = 20, default)] + pub required_document_types: Vec, + #[cultcache(key = 21, default)] + pub schema_preflight_passed: bool, + #[cultcache(key = 22, default)] + pub schema_catalog_sha256: String, } #[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)] @@ -3988,6 +3998,16 @@ fn validate_daemon_service_lifecycle_receipt( return Err(anyhow!("daemon service lifecycle receipt missing {label}")); } } + if !receipt.required_document_types.is_empty() + && (!receipt.schema_preflight_passed + || receipt.executable_sha256.trim().is_empty() + || receipt.schema_catalog_sha256.trim().is_empty() + || receipt.preflight_witness_id.trim().is_empty()) + { + return Err(anyhow!( + "typed daemon service lifecycle receipt requires passing schema preflight, executable fingerprint, and preflight witness" + )); + } Ok(()) } @@ -7313,6 +7333,11 @@ mod tests { operator_artifact_ref: "artifact://service-lifecycle/first".to_string(), private_state_exposed: false, notes: Vec::new(), + executable_sha256: String::new(), + preflight_witness_id: String::new(), + required_document_types: Vec::new(), + schema_preflight_passed: false, + schema_catalog_sha256: String::new(), }; let mut second = first.clone(); second.receipt_id = "service-lifecycle-second".to_string(); @@ -7378,6 +7403,11 @@ mod tests { .to_string(), private_state_exposed: false, notes: Vec::new(), + executable_sha256: String::new(), + preflight_witness_id: String::new(), + required_document_types: Vec::new(), + schema_preflight_passed: false, + schema_catalog_sha256: String::new(), }, ]); let runbook_check = report diff --git a/epiphany-core/src/lib.rs b/epiphany-core/src/lib.rs index 6cd41a3d..62a43314 100644 --- a/epiphany-core/src/lib.rs +++ b/epiphany-core/src/lib.rs @@ -818,6 +818,7 @@ pub use runtime_spine::runtime_job_snapshot; pub use runtime_spine::runtime_latest_hands_receipt_chain_after; pub use runtime_spine::runtime_mind_gateway_review; pub use runtime_spine::runtime_mind_state_commit_receipt; +pub use runtime_spine::runtime_registered_document_types; pub use runtime_spine::runtime_reorient_worker_result; pub use runtime_spine::runtime_repo_work_map_entry; pub use runtime_spine::runtime_repo_work_modeling_finding; diff --git a/epiphany-core/src/runtime_spine.rs b/epiphany-core/src/runtime_spine.rs index e7161f6e..e69377ce 100644 --- a/epiphany-core/src/runtime_spine.rs +++ b/epiphany-core/src/runtime_spine.rs @@ -789,7 +789,7 @@ pub fn initialize_runtime_spine( runtime_kind: "epiphany.native".to_string(), created_at, updated_at: options.created_at, - supported_document_types: supported_runtime_document_types(), + supported_document_types: runtime_registered_document_types(), metadata: BTreeMap::from([("codexEvacuationBridge".to_string(), "temporary".to_string())]), }; cache.put(RUNTIME_IDENTITY_KEY, &identity)?; @@ -1117,7 +1117,7 @@ pub fn prepare_runtime_spine_heartbeat_job( .map(|value| value.created_at.clone()) .unwrap_or_else(|| options.created_at.clone()), updated_at: options.created_at.clone(), - supported_document_types: supported_runtime_document_types(), + supported_document_types: runtime_registered_document_types(), metadata: BTreeMap::from([("codexEvacuationBridge".to_string(), "temporary".to_string())]), }; let session = match cache.get::(&options.session_id)? { @@ -2544,7 +2544,7 @@ fn require_identity(cache: &CultCache) -> Result { .ok_or_else(|| anyhow!("runtime spine is missing identity; run init first")) } -fn supported_runtime_document_types() -> Vec { +pub fn runtime_registered_document_types() -> Vec { let mut document_types = Vec::new(); for contract in epiphany_mutation_contracts() { if !document_types.contains(&contract.document_type) { diff --git a/epiphany-openai-runtime/Cargo.toml b/epiphany-openai-runtime/Cargo.toml index f794f937..6c14a0c9 100644 --- a/epiphany-openai-runtime/Cargo.toml +++ b/epiphany-openai-runtime/Cargo.toml @@ -20,6 +20,7 @@ epiphany-tool-adapter = { path = "../epiphany-tool-adapter" } rmp-serde = "1" serde = { version = "1", features = ["derive"] } serde_json = "1" +sha2 = "0.10" tokio = { version = "1", features = ["macros", "rt-multi-thread"] } uuid = { version = "1", features = ["v4"] } diff --git a/epiphany-openai-runtime/src/bin/epiphany-openai-runtime.rs b/epiphany-openai-runtime/src/bin/epiphany-openai-runtime.rs index 7391bee4..629ec269 100644 --- a/epiphany-openai-runtime/src/bin/epiphany-openai-runtime.rs +++ b/epiphany-openai-runtime/src/bin/epiphany-openai-runtime.rs @@ -39,6 +39,8 @@ use epiphany_openai_runtime::run_worker_launch; use epiphany_tool_adapter::EpiphanyToolInvocationIntent; use epiphany_tool_adapter::tool_invocation_intent_key; use serde_json::json; +use sha2::Digest; +use sha2::Sha256; use uuid::Uuid; const DEFAULT_STORE: &str = "state/runtime-spine.msgpack"; @@ -49,6 +51,65 @@ async fn main() -> Result<()> { let mut args = env::args().skip(1); let command = args.next().unwrap_or_else(|| "usage".to_string()); match command.as_str() { + "preflight" => { + let mut store = PathBuf::from(DEFAULT_STORE); + let mut required_document_types = Vec::new(); + let mut args = args.peekable(); + while let Some(arg) = args.next() { + match arg.as_str() { + "--store" => { + store = + PathBuf::from(args.next().context("preflight missing --store value")?) + } + "--require-document-type" => required_document_types.push( + args.next() + .context("preflight missing --require-document-type value")?, + ), + other => return Err(anyhow!("unknown preflight argument: {other}")), + } + } + let status = epiphany_core::runtime_spine_status(&store)?; + if !status.present { + return Err(anyhow!("runtime spine is absent at {}", store.display())); + } + let registered_document_types = epiphany_core::runtime_registered_document_types(); + let missing: Vec = required_document_types + .iter() + .filter(|required| !registered_document_types.contains(required)) + .cloned() + .collect(); + if !missing.is_empty() { + return Err(anyhow!( + "runtime does not register required document types: {}", + missing.join(", ") + )); + } + let executable = env::current_exe()?.canonicalize()?; + let executable_sha256 = format!("{:x}", Sha256::digest(fs::read(&executable)?)); + let schema_catalog_sha256 = format!( + "{:x}", + Sha256::digest(registered_document_types.join("\n").as_bytes()) + ); + let preflight_witness_id = format!( + "openai-runtime-preflight-{}", + executable_sha256.chars().take(16).collect::() + ); + print_json(&json!({ + "schemaVersion": "epiphany.openai_runtime.preflight.v0", + "status": "passed", + "runtimeVersion": env!("CARGO_PKG_VERSION"), + "executable": executable, + "executableSha256": executable_sha256, + "schemaCatalogSha256": schema_catalog_sha256, + "preflightWitnessId": preflight_witness_id, + "runtimeStore": store, + "runtimeId": status.runtime_id, + "requiredDocumentTypes": required_document_types, + "registeredDocumentTypes": registered_document_types, + "schemaPreflightPassed": true, + "privateStateExposed": false + }))?; + } "model-turn" => { let options = parse_model_turn_options(args.collect())?; require_supported_provider(&options.provider)?; diff --git a/notes/epiphany-current-algorithmic-map.md b/notes/epiphany-current-algorithmic-map.md index 2f24b66d..0314362e 100644 --- a/notes/epiphany-current-algorithmic-map.md +++ b/notes/epiphany-current-algorithmic-map.md @@ -165,6 +165,16 @@ review mouth. Scheduler job IDs include the route generation and derive the stable route key from the item, so neither close JSON nor an old completed job can select current work. +Before any Modeling runtime job is opened, the exact consumer executable runs +`preflight` against the actual runtime store. Its own schema registry must read +the store and advertise the required route, request, finding, and worker-launch +types. Preflight hashes both executable bytes and the ordered supported schema +catalog. Idunn refuses a typed launch without the passing schema flag, +executable SHA-256, schema-catalog SHA-256, witness ID, and required document +list; all are persisted in the daemon service lifecycle receipt. The preflight +ID is correctly a witness, not a fake independent receipt. Preflight precedes +`open_runtime_spine_heartbeat_job`, so stale consumers leave no queued corpse. + The accepted interpretation is persisted as `epiphany.modeling.repo_work_finding.v0`; it references the passing Soul verdict, diff --git a/notes/epiphany-fork-implementation-plan.md b/notes/epiphany-fork-implementation-plan.md index 4106a3b1..1ef6efec 100644 --- a/notes/epiphany-fork-implementation-plan.md +++ b/notes/epiphany-fork-implementation-plan.md @@ -204,9 +204,8 @@ Delete or demote: ## Immediate Next Action -Expose the launched worker executable's build/schema fingerprint in Idunn's -lifecycle receipt and preflight required runtime document registration before -launch. A stale `epiphany-openai-runtime` binary already proved it can otherwise -impersonate a Modeling failure after the producer adds a schema. Keep the new -typed route owner and reviewed generation transition intact; do not repair -stale consumers by mutating requests or findings. +Add a native end-to-end generation-one repo-work Modeling smoke. Begin with a +non-passing runtime-authored generation-zero finding, exercise the explicit +Mind-reviewed `revise-modeling` mouth, launch generation one through Idunn and +runtime-schema preflight, admit only the generation-one finding, and prove +generation zero cannot close or regain current authority. diff --git a/notes/fresh-workspace-handoff.md b/notes/fresh-workspace-handoff.md index 85c3a6ef..f4ea45f9 100644 --- a/notes/fresh-workspace-handoff.md +++ b/notes/fresh-workspace-handoff.md @@ -2115,6 +2115,21 @@ runtime lacked the new route schema; rebuilding the consumer made v2 pass. Next expose executable build/schema fingerprint in the Idunn lifecycle receipt and refuse launch before work when the consumer cannot register required typed documents. +That preflight is now live. `epiphany-openai-runtime preflight` reads the actual +store with the consumer's own registry, requires named document types, and +hashes both the executable and ordered supported schema catalog. An impossible +required type returned exit 1. The scheduler runs preflight before opening a +runtime job. Idunn's typed lifecycle receipt persists `executableSha256`, +`schemaCatalogSha256`, `preflightWitnessId`, `requiredDocumentTypes`, and +`schemaPreflightPassed`; the supervisor refuses incomplete typed launch cargo. +Authenticated live item `runtime-preflight-witness` carried executable SHA-256 +`dd36334e993c64290a0e3ffcf76965fdd2ac1819e84fb37e4be65735ce47f64b`, +returned a passing runtime finding, and closed through Mind/map admission. +Authority tests pass 4/4, core library 248/248, runtime 8/8, and all core bins +type-check. Next add a native end-to-end generation-one smoke that begins with +a non-passing runtime finding, exercises `revise-modeling`, launches `g1` +through Idunn/preflight, and proves generation zero cannot close or regain +current authority. ## Immediate Re-entry Instruction diff --git a/state/ledgers.msgpack b/state/ledgers.msgpack index d42d91a2..37b34e6d 100644 Binary files a/state/ledgers.msgpack and b/state/ledgers.msgpack differ diff --git a/state/map.yaml b/state/map.yaml index dd013570..2633c63e 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: Expose the launched worker executable build/schema fingerprint in Idunn's lifecycle receipt and preflight required runtime document registration before launch. The first typed-route live probe found a stale epiphany-openai-runtime binary; after rebuild, generation-zero item typed-modeling-route-v2 closed successfully. Preserve the typed route owner and Mind-reviewed generation transition; do not mutate requests/findings to compensate for stale consumers. + next_action: Add a native end-to-end generation-one repo-work Modeling smoke. Begin with a non-passing runtime-authored generation-zero finding, exercise the explicit Mind-reviewed revise-modeling mouth, launch generation one through Idunn plus runtime-schema preflight, admit only generation one, and prove generation zero cannot close or regain current authority.