Preflight Modeling runtime schemas

This commit is contained in:
Meta Vens 2026-07-12 12:09:36 +01:00
commit e76676642b
13 changed files with 284 additions and 12 deletions

View file

@ -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<String>,
stdout_artifact: Option<PathBuf>,
stderr_artifact: Option<PathBuf>,
executable_sha256: Option<String>,
schema_catalog_sha256: Option<String>,
preflight_witness_id: Option<String>,
required_document_types: Vec<String>,
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,
})
}
}

View file

@ -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",

View file

@ -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()));
}

View file

@ -1459,6 +1459,16 @@ pub struct EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry {
pub private_state_exposed: bool,
#[cultcache(key = 17)]
pub notes: Vec<String>,
#[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<String>,
#[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

View file

@ -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;

View file

@ -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::<EpiphanyRuntimeSession>(&options.session_id)? {
@ -2544,7 +2544,7 @@ fn require_identity(cache: &CultCache) -> Result<EpiphanyRuntimeIdentity> {
.ok_or_else(|| anyhow!("runtime spine is missing identity; run init first"))
}
fn supported_runtime_document_types() -> Vec<String> {
pub fn runtime_registered_document_types() -> Vec<String> {
let mut document_types = Vec::new();
for contract in epiphany_mutation_contracts() {
if !document_types.contains(&contract.document_type) {

View file

@ -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"] }

View file

@ -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<String> = 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::<String>()
);
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)?;

View file

@ -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,

View file

@ -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.

View file

@ -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

Binary file not shown.

View file

@ -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.