Preflight Modeling runtime schemas
This commit is contained in:
parent
abce2aaf0a
commit
e76676642b
13 changed files with 284 additions and 12 deletions
|
|
@ -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,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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",
|
||||
|
|
|
|||
|
|
@ -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()));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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) {
|
||||
|
|
|
|||
|
|
@ -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"] }
|
||||
|
||||
|
|
|
|||
|
|
@ -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)?;
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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.
|
|
@ -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.
|
||||
|
|
|
|||
Reference in a new issue