From 2c9b904b6cfe97ec238aa9cef5705318b7091e95 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Wed, 15 Jul 2026 10:55:30 +0100 Subject: [PATCH] Purify live semantic projector state --- epiphany-core/src/agent_memory.rs | 2 + .../src/bin/epiphany-daemon-supervisor.rs | 118 +++++- .../bin/epiphany-memory-semantic-projector.rs | 50 ++- epiphany-core/src/cultmesh_integration.rs | 68 +++- epiphany-core/src/lib.rs | 6 + .../src/memory_graph/semantic_projector.rs | 385 ++++++++++++++++++ epiphany-core/src/runtime_spine.rs | 2 + notes/fresh-workspace-handoff.md | 43 ++ state/agents.msgpack | Bin 24006 -> 24346 bytes state/ledgers.msgpack | Bin 500612 -> 501332 bytes state/map.yaml | 2 +- vendor/cultcache-rs | 2 +- 12 files changed, 657 insertions(+), 21 deletions(-) diff --git a/epiphany-core/src/agent_memory.rs b/epiphany-core/src/agent_memory.rs index f7384399..be6015bd 100644 --- a/epiphany-core/src/agent_memory.rs +++ b/epiphany-core/src/agent_memory.rs @@ -2532,6 +2532,8 @@ fn agent_memory_cache(store_path: &Path) -> Result { cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; + cache.register_entry_type::()?; + cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.add_generic_backing_store(SingleFileMessagePackBackingStore::new(store_path)); diff --git a/epiphany-core/src/bin/epiphany-daemon-supervisor.rs b/epiphany-core/src/bin/epiphany-daemon-supervisor.rs index f102e96b..31408ca0 100644 --- a/epiphany-core/src/bin/epiphany-daemon-supervisor.rs +++ b/epiphany-core/src/bin/epiphany-daemon-supervisor.rs @@ -31,8 +31,15 @@ use epiphany_core::load_epiphany_cultmesh_managed_service_policy; use epiphany_core::load_epiphany_cultmesh_managed_service_policy_with_digest; use epiphany_core::load_epiphany_cultmesh_status; use epiphany_core::load_epiphany_cultmesh_swarm_brake; +use epiphany_core::load_latest_epiphany_cultmesh_daemon_heartbeat; +use epiphany_core::load_latest_epiphany_cultmesh_daemon_service_lifecycle_receipt_for_service; +use epiphany_core::migrate_memory_semantic_projection_attempts_v0; use epiphany_core::observe_native_process as observe_process; use epiphany_core::query_epiphany_local_verse_context; +use epiphany_core::retire_epiphany_cultmesh_operator_status_documents; +use epiphany_core::retire_memory_semantic_projection_claims_v0; +use epiphany_core::retire_orphaned_memory_semantic_projection_attempts_v0; +use epiphany_core::retire_unowned_memory_semantic_index_receipts; use epiphany_core::runtime_modeling_semantic_projection_input; use epiphany_core::seed_epiphany_local_verse_context; use epiphany_core::write_epiphany_cultmesh_daemon_poke_intent; @@ -66,6 +73,9 @@ fn main() -> Result<()> { "tick" | "schedule" | "reconcile-all" => tick(args), "serve" | "loop" | "daemon" => serve(args), "managed-service-serve" | "service-desired-state-serve" => managed_service_serve(args), + "migrate-retired-operator-status" => migrate_retired_operator_status(args), + "migrate-semantic-attempts-v0" => migrate_semantic_attempts_v0(args), + "semantic-projector-service-status" => semantic_projector_service_status(args), "service-plan" => service_plan(args), "service-launch" | "launch-service" | "start-service" => service_launch(args), "managed-service-policy" | "service-desired-state" => managed_service_policy(args), @@ -147,6 +157,96 @@ fn main() -> Result<()> { } } +fn migrate_retired_operator_status(args: Args) -> Result<()> { + let removed_keys = retire_epiphany_cultmesh_operator_status_documents(&args.store)?; + println!( + "{}", + serde_json::to_string_pretty(&json!({ + "schemaVersion": "epiphany.cultmesh.retired_document_migration.v0", + "status": "completed", + "retiredDocumentType": "epiphany.cultmesh.operator_status", + "removedKeys": removed_keys, + "privateStateExposed": false, + }))? + ); + Ok(()) +} + +fn migrate_semantic_attempts_v0(args: Args) -> Result<()> { + let agent_store = args + .agent_store + .as_ref() + .context("migrate-semantic-attempts-v0 requires --agent-store")?; + let runtime_store = args + .runtime_store + .as_ref() + .context("migrate-semantic-attempts-v0 requires --runtime-store")?; + if agent_store == runtime_store { + anyhow::bail!("semantic Mind and Modeling stores must remain distinct"); + } + let retired_mind_claim_ids = retire_memory_semantic_projection_claims_v0(agent_store)?; + let retired_modeling_claim_ids = retire_memory_semantic_projection_claims_v0(runtime_store)?; + let retired_mind_attempt_ids = + retire_orphaned_memory_semantic_projection_attempts_v0(agent_store)?; + let retired_modeling_attempt_ids = + retire_orphaned_memory_semantic_projection_attempts_v0(runtime_store)?; + let retired_mind_receipt_ids = retire_unowned_memory_semantic_index_receipts(agent_store)?; + let retired_modeling_receipt_ids = + retire_unowned_memory_semantic_index_receipts(runtime_store)?; + let mind_attempt_ids = migrate_memory_semantic_projection_attempts_v0(agent_store)?; + let modeling_attempt_ids = migrate_memory_semantic_projection_attempts_v0(runtime_store)?; + println!( + "{}", + serde_json::to_string_pretty(&json!({ + "schemaVersion": "epiphany.memory_semantic_projection_attempt_migration.v0", + "status": "completed", + "retiredMindClaimIds": retired_mind_claim_ids, + "retiredModelingClaimIds": retired_modeling_claim_ids, + "retiredMindAttemptIds": retired_mind_attempt_ids, + "retiredModelingAttemptIds": retired_modeling_attempt_ids, + "retiredMindReceiptIds": retired_mind_receipt_ids, + "retiredModelingReceiptIds": retired_modeling_receipt_ids, + "mindAttemptIds": mind_attempt_ids, + "modelingAttemptIds": modeling_attempt_ids, + "privateStateExposed": false, + }))? + ); + Ok(()) +} + +fn semantic_projector_service_status(args: Args) -> Result<()> { + let receipt = load_latest_epiphany_cultmesh_daemon_service_lifecycle_receipt_for_service( + &args.store, + args.runtime_id.clone(), + SEMANTIC_PROJECTOR_SERVICE_ID, + )? + .context("semantic projector launch receipt is absent")?; + let heartbeat = load_latest_epiphany_cultmesh_daemon_heartbeat( + &args.store, + args.runtime_id, + SEMANTIC_PROJECTOR_EXECUTOR_ID, + )? + .context("semantic projector heartbeat is absent")?; + let correlation_matches = heartbeat.startup_lifecycle_receipt_id == receipt.receipt_id; + println!( + "{}", + serde_json::to_string_pretty(&json!({ + "schemaVersion": "epiphany.memory_semantic_projector_service_status.v0", + "status": if correlation_matches && heartbeat.status == "ready" { "ready" } else { "degraded" }, + "processId": receipt.process_id, + "launchReceiptId": receipt.receipt_id, + "executableSha256": receipt.executable_sha256, + "heartbeatId": heartbeat.heartbeat_id, + "providerIncarnation": heartbeat.provider_incarnation, + "heartbeatStatus": heartbeat.status, + "startupCorrelationMatches": correlation_matches, + "privateStateExposed": false, + "authoritative": false, + }))? + ); + Ok(()) +} + fn semantic_projection_input(args: &Args) -> Result<(MemorySemanticProjectionInput, &Path)> { match (&args.agent_store, &args.runtime_store) { (Some(path), None) => Ok((agent_memory_semantic_projection_input(path)?, path)), @@ -389,13 +489,21 @@ fn service_launch(args: Args) -> Result<()> { if args.wait_child { anyhow::bail!("reserved semantic projector launch is an infinite managed child"); } - Some((policy.policy_id, digest, Uuid::new_v4().to_string())) + let executable_sha256 = local_file_sha256(&command_path.display().to_string()) + .map(|digest| format!("sha256-{digest}")) + .context("reserved semantic projector executable cannot be fingerprinted")?; + Some(( + policy.policy_id, + digest, + Uuid::new_v4().to_string(), + executable_sha256, + )) } else { None }; let mut command = Command::new(&command_path); command.args(&service_args); - if let Some((_, _, receipt_id)) = &reserved_launch { + if let Some((_, _, receipt_id, _)) = &reserved_launch { command.env("EPIPHANY_STARTUP_LIFECYCLE_RECEIPT_ID", receipt_id); } if let Some(stdout_path) = &args.stdout_artifact { @@ -454,12 +562,13 @@ fn service_launch(args: Args) -> Result<()> { .as_ref() .map(|path| path.display().to_string()), ); - if let Some((policy_id, policy_digest, receipt_id)) = reserved_launch { + if let Some((policy_id, policy_digest, receipt_id, executable_sha256)) = reserved_launch { receipt.receipt_id = receipt_id.clone(); receipt.managed_policy_id = policy_id; receipt.managed_policy_digest = policy_digest; receipt.provider_daemon_id = SEMANTIC_PROJECTOR_EXECUTOR_ID.to_string(); receipt.startup_correlation_id = receipt_id; + receipt.executable_sha256 = executable_sha256; } let written = match write_epiphany_cultmesh_daemon_service_lifecycle_receipt( &args.store, @@ -4131,6 +4240,9 @@ impl Args { | "daemon" | "managed-service-serve" | "service-desired-state-serve" + | "migrate-retired-operator-status" + | "migrate-semantic-attempts-v0" + | "semantic-projector-service-status" | "service-plan" | "install-service" | "service-launch" diff --git a/epiphany-core/src/bin/epiphany-memory-semantic-projector.rs b/epiphany-core/src/bin/epiphany-memory-semantic-projector.rs index 6dafb7fd..2e7d6524 100644 --- a/epiphany-core/src/bin/epiphany-memory-semantic-projector.rs +++ b/epiphany-core/src/bin/epiphany-memory-semantic-projector.rs @@ -1,15 +1,17 @@ use anyhow::{Context, Result, anyhow}; use epiphany_core::{ EPIPHANY_CULTMESH_DAEMON_HEARTBEAT_EVENT_SCHEMA_VERSION, - EpiphanyCultMeshDaemonHeartbeatEventEntry, MemorySemanticIndexConfig, - MemorySemanticProjectionInput, MemorySemanticProjectorPulseStatus, + EpiphanyCultMeshDaemonHeartbeatEventEntry, EpiphanyCultMeshDaemonServiceLifecycleReceiptEntry, + MemorySemanticIndexConfig, MemorySemanticProjectionInput, MemorySemanticProjectorPulseStatus, SemanticProjectorServiceBody, authenticate_epiphany_cultmesh_semantic_projector_launch, load_epiphany_cultmesh_daemon_service_lifecycle_receipt, publish_epiphany_cultmesh_semantic_projection_health, write_epiphany_cultmesh_daemon_heartbeat_event, }; use serde_json::json; +use sha2::{Digest, Sha256}; use std::env; +use std::fs; use std::path::PathBuf; use std::thread; use std::time::Duration; @@ -26,7 +28,27 @@ fn main() -> Result<()> { "managed projector requires its startup launch receipt id" )); } - authenticate_managed_launch(&args)?; + let receipt = authenticate_managed_launch(&args)?; + if receipt.process_id != Some(std::process::id()) { + return Err(anyhow!( + "managed projector process disagrees with its launch receipt" + )); + } + let executable = env::current_exe().context("failed to resolve projector executable")?; + let executable_sha256 = format!( + "sha256-{:x}", + Sha256::digest(fs::read(&executable).with_context(|| { + format!( + "failed to fingerprint projector executable {}", + executable.display() + ) + })?) + ); + if receipt.executable_sha256 != executable_sha256 { + return Err(anyhow!( + "managed projector executable disagrees with its launch receipt" + )); + } } let mut semantic_config = MemorySemanticIndexConfig::from_env(); semantic_config.qdrant_url = args.qdrant_url.clone(); @@ -48,21 +70,21 @@ fn main() -> Result<()> { .clone() .or_else(|| outcome.inspections.last().map(|row| row.scope_id.clone())); - let mut health_faults = 0_u32; + let mut health_publication_faults = Vec::new(); for input in &inputs { let store = source_store(&args, input)?; - if publish_epiphany_cultmesh_semantic_projection_health( + if let Err(error) = publish_epiphany_cultmesh_semantic_projection_health( &args.local_verse_store, args.runtime_id.clone(), store, input, &provider_incarnation, - ) - .is_err() - { - health_faults += 1; + ) { + health_publication_faults + .push(format!("{}: {error:#}", input.obligation().partition)); } } + let health_faults = health_publication_faults.len() as u32; let degraded = source_faults > 0 || health_faults > 0 || matches!( @@ -98,6 +120,7 @@ fn main() -> Result<()> { "inspectedSourceCount": outcome.inspections.len(), "sourceFaultCount": source_faults, "healthPublicationFaultCount": health_faults, + "healthPublicationFaults": health_publication_faults, "selectedScopeId": outcome.selected_scope_id, "privateStateExposed": false, "authoritative": false, @@ -112,7 +135,9 @@ fn main() -> Result<()> { Ok(()) } -fn authenticate_managed_launch(args: &Args) -> Result<()> { +fn authenticate_managed_launch( + args: &Args, +) -> Result { let deadline = Instant::now() + Duration::from_secs(5); loop { if load_epiphany_cultmesh_daemon_service_lifecycle_receipt( @@ -122,12 +147,11 @@ fn authenticate_managed_launch(args: &Args) -> Result<()> { )? .is_some() { - authenticate_epiphany_cultmesh_semantic_projector_launch( + return authenticate_epiphany_cultmesh_semantic_projector_launch( &args.local_verse_store, args.runtime_id.clone(), &args.startup_lifecycle_receipt_id, - )?; - return Ok(()); + ); } if Instant::now() >= deadline { return Err(anyhow!( diff --git a/epiphany-core/src/cultmesh_integration.rs b/epiphany-core/src/cultmesh_integration.rs index 3a837a6a..78461f0b 100644 --- a/epiphany-core/src/cultmesh_integration.rs +++ b/epiphany-core/src/cultmesh_integration.rs @@ -2675,6 +2675,26 @@ pub fn open_epiphany_cultmesh_node( ) } +/// Removes the extinct ownerless operator-status projection from an existing +/// local Verse so the live schema catalog can open it again. +/// +/// This is deliberately explicit migration, never implicit node bootstrap. +pub fn retire_epiphany_cultmesh_operator_status_documents( + store_path: impl AsRef, +) -> Result> { + const RETIRED_TYPE: &str = "epiphany.cultmesh.operator_status"; + let mut backing = SingleFileMessagePackBackingStore::new(store_path.as_ref()); + let retired = backing + .pull_all()? + .into_iter() + .filter(|entry| entry.r#type == RETIRED_TYPE) + .collect::>(); + for entry in &retired { + backing.delete(entry)?; + } + Ok(retired.into_iter().map(|entry| entry.key).collect()) +} + fn semantic_projection_health_scope_key(swarm_id: &str, partition: &str) -> String { use sha2::{Digest, Sha256}; format!( @@ -4251,6 +4271,15 @@ pub fn load_latest_epiphany_cultmesh_daemon_service_lifecycle_receipt( node.get(EPIPHANY_CULTMESH_DAEMON_SERVICE_LIFECYCLE_RECEIPT_LATEST_KEY) } +pub fn load_latest_epiphany_cultmesh_daemon_service_lifecycle_receipt_for_service( + store_path: impl AsRef, + runtime_id: impl Into, + service_id: &str, +) -> Result> { + let node = open_epiphany_cultmesh_node(store_path, runtime_id)?; + node.get(&epiphany_cultmesh_daemon_service_lifecycle_receipt_latest_key(service_id)) +} + pub fn load_epiphany_cultmesh_daemon_service_lifecycle_receipts( store_path: impl AsRef, runtime_id: impl Into, @@ -4871,6 +4900,7 @@ fn validate_semantic_projector_launch_receipt( || receipt.process_id.is_none() || receipt.exit_code.is_some() || receipt.completed_at_utc.is_none() + || !receipt.executable_sha256.starts_with("sha256-") || receipt.managed_policy_id.trim().is_empty() || !receipt.managed_policy_digest.starts_with("sha256-") || receipt.provider_daemon_id != "epiphany-memory-semantic-projector" @@ -8035,8 +8065,40 @@ pub fn write_epiphany_cultmesh_bifrost_contracts( mod tests { use super::*; use cultcache_rs::CacheBackingStore; + use cultcache_rs::CultCacheEnvelope; use pretty_assertions::assert_eq; + #[test] + fn explicit_migration_removes_only_retired_operator_status_documents() -> Result<()> { + let temp = tempfile::tempdir()?; + let store = temp.path().join("verse.ccmp"); + let mut backing = SingleFileMessagePackBackingStore::new(&store); + backing.push(&CultCacheEnvelope { + key: "epiphany-local/operator-status/latest".into(), + r#type: "epiphany.cultmesh.operator_status".into(), + payload: vec![0x80], + stored_at: "2026-07-15T10:00:00Z".into(), + schema_id: Some("epiphany.cultmesh.operator_status".into()), + })?; + backing.push(&CultCacheEnvelope { + key: "epiphany-local/status".into(), + r#type: EPIPHANY_CULTMESH_STATUS_TYPE.into(), + payload: vec![0x80], + stored_at: "2026-07-15T10:00:01Z".into(), + schema_id: Some(EPIPHANY_CULTMESH_STATUS_TYPE.into()), + })?; + + assert_eq!( + retire_epiphany_cultmesh_operator_status_documents(&store)?, + vec!["epiphany-local/operator-status/latest"] + ); + let remaining = backing.pull_all()?; + assert_eq!(remaining.len(), 1); + assert_eq!(remaining[0].r#type, EPIPHANY_CULTMESH_STATUS_TYPE); + assert!(retire_epiphany_cultmesh_operator_status_documents(&store)?.is_empty()); + Ok(()) + } + #[test] fn reserved_semantic_projector_policy_requires_specialized_exact_writer() -> Result<()> { let temp = tempfile::tempdir()?; @@ -8128,7 +8190,7 @@ mod tests { operator_artifact_ref: "service://semantic-projector/launch".into(), private_state_exposed: false, notes: vec![], - executable_sha256: String::new(), + executable_sha256: "sha256-test-projector".into(), preflight_witness_id: String::new(), required_document_types: vec![], schema_preflight_passed: false, @@ -8716,7 +8778,7 @@ mod tests { operator_artifact_ref: "artifact://service-lifecycle/first".to_string(), private_state_exposed: false, notes: Vec::new(), - executable_sha256: String::new(), + executable_sha256: "sha256-test-projector".into(), preflight_witness_id: String::new(), required_document_types: Vec::new(), schema_preflight_passed: false, @@ -11546,7 +11608,7 @@ mod tests { operator_artifact_ref: "service://semantic-projector/launch".into(), private_state_exposed: false, notes: vec![], - executable_sha256: String::new(), + executable_sha256: "sha256-test-projector".into(), preflight_witness_id: String::new(), required_document_types: vec![], schema_preflight_passed: false, diff --git a/epiphany-core/src/lib.rs b/epiphany-core/src/lib.rs index be96c7f5..96fce00d 100644 --- a/epiphany-core/src/lib.rs +++ b/epiphany-core/src/lib.rs @@ -472,6 +472,7 @@ pub use cultmesh_integration::load_latest_epiphany_cultmesh_daemon_poke_intent; pub use cultmesh_integration::load_latest_epiphany_cultmesh_daemon_poke_receipt; pub use cultmesh_integration::load_latest_epiphany_cultmesh_daemon_scheduler_receipt; pub use cultmesh_integration::load_latest_epiphany_cultmesh_daemon_service_lifecycle_receipt; +pub use cultmesh_integration::load_latest_epiphany_cultmesh_daemon_service_lifecycle_receipt_for_service; pub use cultmesh_integration::load_latest_epiphany_cultmesh_daemon_tool_invocation_intent; pub use cultmesh_integration::load_latest_epiphany_cultmesh_daemon_tool_invocation_receipt; pub use cultmesh_integration::load_latest_epiphany_cultmesh_eve_connection_intent; @@ -495,6 +496,7 @@ pub use cultmesh_integration::open_epiphany_cultmesh_node; pub use cultmesh_integration::publish_epiphany_cultmesh_provider_state; pub use cultmesh_integration::publish_epiphany_cultmesh_semantic_projection_health; pub use cultmesh_integration::query_epiphany_local_verse_context; +pub use cultmesh_integration::retire_epiphany_cultmesh_operator_status_documents; pub use cultmesh_integration::seed_epiphany_local_verse_context; pub use cultmesh_integration::write_epiphany_cultmesh_agent_state_soa_summary; #[cfg(test)] @@ -711,11 +713,15 @@ pub use memory_graph::memory_graph_from_heartbeat_cognition; pub use memory_graph::memory_graph_model_hash; pub use memory_graph::memory_graph_node_id; pub use memory_graph::memory_semantic_projection_query_eligible; +pub use memory_graph::migrate_memory_semantic_projection_attempts_v0; pub use memory_graph::observe_memory_semantic_projection; pub use memory_graph::plan_memory_graph_context_cut; pub use memory_graph::plan_memory_graph_context_cut_with_ranked_ids; pub use memory_graph::refresh_or_validate_repo_memory_graph; pub use memory_graph::resolve_semantic_candidate; +pub use memory_graph::retire_memory_semantic_projection_claims_v0; +pub use memory_graph::retire_orphaned_memory_semantic_projection_attempts_v0; +pub use memory_graph::retire_unowned_memory_semantic_index_receipts; pub use memory_graph::semantic_memory_context; pub use memory_graph::semantic_point_id; pub use memory_graph::validate_memory_graph_entry; diff --git a/epiphany-core/src/memory_graph/semantic_projector.rs b/epiphany-core/src/memory_graph/semantic_projector.rs index 76227196..88204bd8 100644 --- a/epiphany-core/src/memory_graph/semantic_projector.rs +++ b/epiphany-core/src/memory_graph/semantic_projector.rs @@ -11,6 +11,7 @@ use cultcache_rs::{ SingleFileMessagePackBackingStore, }; use serde::de::DeserializeOwned; +use serde::{Deserialize, Serialize}; use sha2::{Digest, Sha256}; use std::path::Path; @@ -21,6 +22,231 @@ pub const MEMORY_SEMANTIC_PROJECTOR_EXECUTOR_GRANT_SCHEMA_VERSION: &str = pub const MEMORY_SEMANTIC_PROJECTOR_RECOVERY_AUTHORIZATION_SCHEMA_VERSION: &str = "gamecult.epiphany.memory_semantic_projector_recovery_authorization.v2"; +#[derive(Deserialize, Serialize)] +struct LegacyMemorySemanticProjectionAttemptV0 { + schema_version: String, + attempt_id: String, + obligation_id: String, + started_at: String, + completed_at: Option, + status: String, + error: Option, +} + +#[derive(Deserialize, Serialize)] +struct LegacyMemorySemanticProjectionClaimV0 { + schema_version: String, + scope_id: String, + claim_id: String, + obligation_id: String, + attempt_id: String, + executor_id: String, + epoch: u64, + status: String, + claimed_at: String, + completed_at: Option, +} + +/// Retires pre-Idunn claim/attempt pairs from active authority. Their old +/// receipts remain historical and query-ineligible; current obligations can +/// then receive fresh fenced work. +pub fn retire_memory_semantic_projection_claims_v0( + store_path: impl AsRef, +) -> Result> { + const ATTEMPT_TYPE: &str = "gamecult.epiphany.memory_semantic_projection_attempt"; + const CLAIM_TYPE: &str = "gamecult.epiphany.memory_semantic_projection_claim"; + let backing = SingleFileMessagePackBackingStore::new(store_path.as_ref()); + let opening = backing.pull_all()?; + let mut retired = Vec::new(); + for claim_envelope in opening.iter().filter(|entry| entry.r#type == CLAIM_TYPE) { + if rmp_serde::from_slice::(&claim_envelope.payload).is_ok() { + continue; + } + let claim = rmp_serde::from_slice::( + &claim_envelope.payload, + )?; + if claim.schema_version != "gamecult.epiphany.memory_semantic_projection_claim.v0" { + return Err(anyhow!( + "unsupported legacy semantic claim schema for {:?}", + claim.claim_id + )); + } + let attempt_envelope = opening + .iter() + .find(|entry| entry.r#type == ATTEMPT_TYPE && entry.key == claim.attempt_id) + .ok_or_else(|| { + anyhow!( + "legacy semantic claim {:?} has no exact attempt", + claim.claim_id + ) + })?; + let attempt = rmp_serde::from_slice::( + &attempt_envelope.payload, + )?; + if attempt.attempt_id != claim.attempt_id || attempt.obligation_id != claim.obligation_id { + return Err(anyhow!("legacy semantic claim/attempt pair disagrees")); + } + if !backing + .delete_batch_if_unchanged(&[claim_envelope.clone(), attempt_envelope.clone()])? + { + return Err(anyhow!( + "legacy semantic authority changed during explicit retirement" + )); + } + retired.push(claim.claim_id); + } + Ok(retired) +} + +/// Retires historical v0 attempts whose scope claim was already superseded or +/// overwritten before fenced claim history existed. +pub fn retire_orphaned_memory_semantic_projection_attempts_v0( + store_path: impl AsRef, +) -> Result> { + const ATTEMPT_TYPE: &str = "gamecult.epiphany.memory_semantic_projection_attempt"; + const CLAIM_TYPE: &str = "gamecult.epiphany.memory_semantic_projection_claim"; + let backing = SingleFileMessagePackBackingStore::new(store_path.as_ref()); + let opening = backing.pull_all()?; + let current_claim_attempt_ids = opening + .iter() + .filter(|entry| entry.r#type == CLAIM_TYPE) + .filter_map(|entry| { + rmp_serde::from_slice::(&entry.payload) + .ok() + .map(|claim| claim.attempt_id) + }) + .collect::>(); + let mut retired = Vec::new(); + for attempt_envelope in opening.iter().filter(|entry| entry.r#type == ATTEMPT_TYPE) { + if rmp_serde::from_slice::(&attempt_envelope.payload) + .is_ok() + { + continue; + } + let attempt = rmp_serde::from_slice::( + &attempt_envelope.payload, + )?; + if attempt.schema_version != "gamecult.epiphany.memory_semantic_projection_attempt.v0" { + return Err(anyhow!( + "unsupported orphaned semantic attempt schema for {:?}", + attempt.attempt_id + )); + } + if current_claim_attempt_ids.contains(&attempt.attempt_id) { + continue; + } + if !backing.delete_batch_if_unchanged(std::slice::from_ref(attempt_envelope))? { + return Err(anyhow!( + "orphaned semantic attempt changed during explicit retirement" + )); + } + retired.push(attempt.attempt_id); + } + Ok(retired) +} + +/// Retires index receipts whose physical claim namespace is absent from the +/// canonical store. Their Qdrant points are rebuildable cache residue. +pub fn retire_unowned_memory_semantic_index_receipts( + store_path: impl AsRef, +) -> Result> { + const RECEIPT_TYPE: &str = "gamecult.epiphany.memory_semantic_index_receipt"; + const CLAIM_TYPE: &str = "gamecult.epiphany.memory_semantic_projection_claim"; + let backing = SingleFileMessagePackBackingStore::new(store_path.as_ref()); + let opening = backing.pull_all()?; + let claim_ids = opening + .iter() + .filter(|entry| entry.r#type == CLAIM_TYPE) + .filter_map(|entry| { + rmp_serde::from_slice::(&entry.payload) + .ok() + .map(|claim| claim.claim_id) + }) + .collect::>(); + let mut retired = Vec::new(); + for envelope in opening.iter().filter(|entry| entry.r#type == RECEIPT_TYPE) { + let receipt = rmp_serde::from_slice::(&envelope.payload)?; + if !receipt.claim_id.trim().is_empty() + && receipt.claim_epoch > 0 + && claim_ids.contains(&receipt.claim_id) + { + continue; + } + if !backing.delete_batch_if_unchanged(std::slice::from_ref(envelope))? { + return Err(anyhow!( + "unowned semantic index receipt changed during explicit retirement" + )); + } + retired.push(receipt.receipt_id); + } + Ok(retired) +} + +/// Upgrades v0 attempt rows by binding them to the exact persisted claim that +/// already owns their attempt identity. No claim means no migration. +pub fn migrate_memory_semantic_projection_attempts_v0( + store_path: impl AsRef, +) -> Result> { + const ATTEMPT_TYPE: &str = "gamecult.epiphany.memory_semantic_projection_attempt"; + const CLAIM_TYPE: &str = "gamecult.epiphany.memory_semantic_projection_claim"; + let backing = SingleFileMessagePackBackingStore::new(store_path.as_ref()); + let opening = backing.pull_all()?; + let claims = opening + .iter() + .filter(|entry| entry.r#type == CLAIM_TYPE) + .map(|entry| rmp_serde::from_slice::(&entry.payload)) + .collect::, _>>()?; + let mut migrated = Vec::new(); + for envelope in opening.iter().filter(|entry| entry.r#type == ATTEMPT_TYPE) { + if rmp_serde::from_slice::(&envelope.payload).is_ok() { + continue; + } + let legacy = + rmp_serde::from_slice::(&envelope.payload)?; + if legacy.schema_version != "gamecult.epiphany.memory_semantic_projection_attempt.v0" { + return Err(anyhow!( + "unsupported legacy semantic attempt schema for {:?}", + legacy.attempt_id + )); + } + let claim = claims + .iter() + .find(|claim| { + claim.attempt_id == legacy.attempt_id && claim.obligation_id == legacy.obligation_id + }) + .ok_or_else(|| { + anyhow!( + "legacy semantic attempt {:?} has no exact owning claim", + legacy.attempt_id + ) + })?; + let upgraded = MemorySemanticProjectionAttempt { + schema_version: MEMORY_SEMANTIC_PROJECTION_ATTEMPT_SCHEMA_VERSION.to_string(), + attempt_id: legacy.attempt_id, + obligation_id: legacy.obligation_id, + started_at: legacy.started_at, + completed_at: legacy.completed_at, + status: legacy.status, + error: legacy.error, + claim_id: claim.claim_id.clone(), + claim_epoch: claim.epoch, + executor_id: claim.executor_id.clone(), + executor_incarnation: claim.executor_incarnation.clone(), + authority_id: claim.authority_id.clone(), + }; + validate_memory_semantic_projection_attempt(&upgraded)?; + let mut replacement: CultCacheEnvelope = envelope.clone(); + replacement.payload = rmp_serde::to_vec_named(&upgraded)?; + if !backing.compare_and_swap_entry(envelope, replacement)? { + return Err(anyhow!( + "semantic attempt changed during explicit migration" + )); + } + migrated.push(upgraded.attempt_id); + } + Ok(migrated) +} + #[derive(Clone, Debug, PartialEq, DatabaseEntry)] #[cultcache( type = "gamecult.epiphany.memory_semantic_projector_executor_grant", @@ -73,6 +299,7 @@ mod authority_tests { use crate::{ MEMORY_SEMANTIC_PROJECTION_OBLIGATION_SCHEMA_VERSION, SEMANTIC_PROJECTION_SCHEMA_VERSION, }; + use anyhow::Context; use tempfile::tempdir; fn obligation() -> MemorySemanticProjectionObligation { @@ -126,6 +353,164 @@ mod authority_tests { }) } + #[test] + fn legacy_attempt_migration_binds_exact_owning_claim() -> Result<()> { + let temp = tempdir()?; + let store = temp.path().join("legacy-attempt.msgpack"); + let obligation = obligation(); + let mut cache = semantic_projector_cache(&store)?; + cache.put(&obligation.obligation_id, &obligation)?; + let projection_input = input(&store, &obligation)?; + let acquisition = idunn_acquire_memory_semantic_projection( + &store, + &projection_input, + "executor-a", + "executor-a-incarnation", + "execute", + "idunn-incarnation-a", + "2026-07-15T04:01:00Z", + )?; + let backing = SingleFileMessagePackBackingStore::new(&store); + let opening = backing.pull_all()?; + let attempt_envelope = opening + .iter() + .find(|entry| { + entry.r#type == MemorySemanticProjectionAttempt::TYPE + && entry.key == acquisition.claim.attempt_id + }) + .context("attempt missing")?; + let attempt: MemorySemanticProjectionAttempt = + rmp_serde::from_slice(&attempt_envelope.payload)?; + let legacy = LegacyMemorySemanticProjectionAttemptV0 { + schema_version: "gamecult.epiphany.memory_semantic_projection_attempt.v0".into(), + attempt_id: attempt.attempt_id.clone(), + obligation_id: attempt.obligation_id.clone(), + started_at: attempt.started_at, + completed_at: attempt.completed_at, + status: attempt.status, + error: attempt.error, + }; + let mut legacy_envelope = attempt_envelope.clone(); + legacy_envelope.payload = rmp_serde::to_vec_named(&legacy)?; + assert!(backing.compare_and_swap_entry(attempt_envelope, legacy_envelope)?); + + assert_eq!( + migrate_memory_semantic_projection_attempts_v0(&store)?, + vec![attempt.attempt_id.clone()] + ); + let (_, _, _, upgraded) = load_running_claim(&store, &acquisition.claim.claim_id)?; + assert_eq!(upgraded.claim_id, acquisition.claim.claim_id); + assert_eq!(upgraded.claim_epoch, acquisition.claim.epoch); + assert_eq!(upgraded.executor_id, acquisition.claim.executor_id); + assert_eq!( + upgraded.executor_incarnation, + acquisition.claim.executor_incarnation + ); + assert_eq!(upgraded.authority_id, acquisition.claim.authority_id); + assert!(migrate_memory_semantic_projection_attempts_v0(&store)?.is_empty()); + Ok(()) + } + + #[test] + fn legacy_unfenced_claim_and_attempt_retire_atomically() -> Result<()> { + let temp = tempdir()?; + let store = temp.path().join("legacy-claim.msgpack"); + let obligation = obligation(); + let mut cache = semantic_projector_cache(&store)?; + cache.put(&obligation.obligation_id, &obligation)?; + let projection_input = input(&store, &obligation)?; + let acquisition = idunn_acquire_memory_semantic_projection( + &store, + &projection_input, + "executor-a", + "executor-a-incarnation", + "execute", + "idunn-incarnation-a", + "2026-07-15T04:01:00Z", + )?; + let backing = SingleFileMessagePackBackingStore::new(&store); + let opening = backing.pull_all()?; + let claim_envelope = exact_envelope( + &opening, + MemorySemanticProjectionClaim::TYPE, + &acquisition.claim.scope_id, + )?; + let attempt_envelope = exact_envelope( + &opening, + MemorySemanticProjectionAttempt::TYPE, + &acquisition.claim.attempt_id, + )?; + let legacy_claim = LegacyMemorySemanticProjectionClaimV0 { + schema_version: "gamecult.epiphany.memory_semantic_projection_claim.v0".into(), + scope_id: acquisition.claim.scope_id.clone(), + claim_id: acquisition.claim.claim_id.clone(), + obligation_id: acquisition.claim.obligation_id.clone(), + attempt_id: acquisition.claim.attempt_id.clone(), + executor_id: acquisition.claim.executor_id.clone(), + epoch: acquisition.claim.epoch, + status: acquisition.claim.status.clone(), + claimed_at: acquisition.claim.claimed_at.clone(), + completed_at: acquisition.claim.completed_at.clone(), + }; + let attempt: MemorySemanticProjectionAttempt = + rmp_serde::from_slice(&attempt_envelope.payload)?; + let legacy_attempt = LegacyMemorySemanticProjectionAttemptV0 { + schema_version: "gamecult.epiphany.memory_semantic_projection_attempt.v0".into(), + attempt_id: attempt.attempt_id, + obligation_id: attempt.obligation_id, + started_at: attempt.started_at, + completed_at: attempt.completed_at, + status: attempt.status, + error: attempt.error, + }; + let mut legacy_claim_envelope = claim_envelope.clone(); + legacy_claim_envelope.payload = rmp_serde::to_vec_named(&legacy_claim)?; + let mut legacy_attempt_envelope = attempt_envelope.clone(); + legacy_attempt_envelope.payload = rmp_serde::to_vec_named(&legacy_attempt)?; + assert!(backing.compare_and_swap_batch( + &[claim_envelope, attempt_envelope], + vec![legacy_claim_envelope, legacy_attempt_envelope], + )?); + + assert_eq!( + retire_memory_semantic_projection_claims_v0(&store)?, + vec![acquisition.claim.claim_id] + ); + let observation = observe_memory_semantic_projection(&store, &projection_input)?; + assert_eq!(observation.status, "pending"); + assert!(retire_memory_semantic_projection_claims_v0(&store)?.is_empty()); + Ok(()) + } + + #[test] + fn orphaned_legacy_attempt_retires_without_fabricated_claim() -> Result<()> { + let temp = tempdir()?; + let store = temp.path().join("orphaned-attempt.msgpack"); + let legacy = LegacyMemorySemanticProjectionAttemptV0 { + schema_version: "gamecult.epiphany.memory_semantic_projection_attempt.v0".into(), + attempt_id: "orphaned-attempt-1".into(), + obligation_id: "obligation-modeling-7".into(), + started_at: "2026-07-15T04:01:00Z".into(), + completed_at: Some("2026-07-15T04:02:00Z".into()), + status: "succeeded".into(), + error: None, + }; + let mut backing = SingleFileMessagePackBackingStore::new(&store); + backing.push(&CultCacheEnvelope { + key: legacy.attempt_id.clone(), + r#type: MemorySemanticProjectionAttempt::TYPE.into(), + payload: rmp_serde::to_vec_named(&legacy)?, + stored_at: "2026-07-15T04:02:00Z".into(), + schema_id: Some(MemorySemanticProjectionAttempt::TYPE.into()), + })?; + assert_eq!( + retire_orphaned_memory_semantic_projection_attempts_v0(&store)?, + vec![legacy.attempt_id] + ); + assert!(backing.pull_all()?.is_empty()); + Ok(()) + } + #[test] fn concurrent_idunn_acquisition_has_one_winner_and_no_issued_litter() -> Result<()> { let temp = tempdir()?; diff --git a/epiphany-core/src/runtime_spine.rs b/epiphany-core/src/runtime_spine.rs index 0185f14d..71065be9 100644 --- a/epiphany-core/src/runtime_spine.rs +++ b/epiphany-core/src/runtime_spine.rs @@ -846,6 +846,8 @@ pub fn runtime_spine_cache(store_path: impl AsRef) -> Result { cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; + cache.register_entry_type::()?; + 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 e0b61200..95a2e7ef 100644 --- a/notes/fresh-workspace-handoff.md +++ b/notes/fresh-workspace-handoff.md @@ -1333,3 +1333,46 @@ and Qdrant tunnel under durable Idunn/OS survival ownership. Live proof must cover real child handshake, bounded pulse, heartbeat and health, forced restart/correlation, singleton refusal, and safe exact recovery/resumption where an abandoned claim can be created without forging canonical work. + +## Live semantic projector proof and canonical purification (2026-07-15) + +The reserved policy is live against shared Yggdrasil Qdrant through +`127.0.0.1:16333` and Yggdrasil Ollama through `10.77.0.1:11435`. Live launch +pressure exposed three fossils that narrow tests had not reached: + +- local Verse still contained the deleted ownerless + `epiphany.cultmesh.operator_status`; an explicit backed-up migration removed + its one key instead of registering extinct authority; +- both canonical stores contained v0 claims/attempts and index receipts from + before Idunn fencing; explicit migration atomically retired those rows from + active authority rather than inventing missing incarnation or grant fields; +- Mind and Modeling canonical cache catalogs registered claims, attempts, and + receipts but not the executor-grant/recovery types now written into the same + physical stores; both readers now register the whole semantic authority + family. + +CultCache now provides an atomic exact-envelope batch deletion primitive for +these migrations. The projector launch receipt also binds executable SHA-256, +and the child verifies both its own PID and its bytes against that receipt +before constructing the service body. Health publication errors are bounded in +the pulse output instead of disappearing into a count. + +Fresh Idunn-granted projection rebuilt Mind (43 documents) and Modeling (3 +documents), both 1024-dimensional and query-eligible. Live semantic context +queries ranked canonical documents for both partitions while ignoring Qdrant +payload text. A clean steady pulse inspected both sources, remained idle, and +published a ready heartbeat with no source or health faults. A second +interactive projector was refused by the host singleton. Killing child PID +22992 caused the reconciler to launch PID 29868 with receipt +`daa89e4f-4301-40eb-aa87-5b52c5017221`; the typed service-status readback proved +the new ready heartbeat names that exact receipt and executable hash. + +Full proof is 375 library tests passed/1 ignored, 7/7 supervisor tests, and all +binaries compiling. The live child and reconciler remain running, but survival +is not yet deployable physiology: reconciler PID 22072 and SSH tunnel PID 22728 +are detached processes, not durable OS-owned services. The existing generic +Windows `sc.exe create` path is not sufficient because this console binary does +not implement the Windows service-control handshake. Build a real service host +or explicit Task Scheduler owner with restart policy, give the Qdrant tunnel +the same durable treatment, and prove startup/reboot recovery. Live abandoned +claim recovery remains unproven; use a safe fixture rather than forging work. diff --git a/state/agents.msgpack b/state/agents.msgpack index 92e0b34dd84ef62a11c60b23b0742cf680de25df..281e14ed383a98999313676ecf428d6b0fb8aea9 100644 GIT binary patch delta 1677 zcmb`HO>5LZ7{{AdSZh~dX{$vlww`>O?PM~UWU4~72%=Ja>DG3)D3h6qR@tQ87qKVL z9tvA#u}~B|sI3=4RzVPCLG)Pg7$}GzLHq)yY0Dz9LfIvUgqi1gGSC12o9EjnZTYiS z>FHQr`k;Plz3)!rWXDo4tbR?L==KYDO@3E)}wRS2|dy85jAVyZ}e&x3}_lAgf4fbVH>6?n2-WN zn=y%P16#U|DT3j@xN8z(JFYM&BwSD%8WyKatEzzv9BHsYx|jJYA!dV zek8ioU}mWK>XnQS8?Ecvj|d_Hpapbud~-ubY0E;{H^nmNQidAT)!NOztIhVM1;^y< z%$Ln9eV5+g7j>`zb|=+9&jzkKn{@rON#@nV+bf00&qqxE^Oj*O9Z2NnfD9x zpeXYps52aFlM5np0dWn81aSd#xCtU$}fC|PKb#2omuo~o|Dr#WrmU=ola-gC0 z%jba^G7i*2XQw(mRceLWj)GZurCIUf+G!1c;uc0&|Hs?i3jcOn=dB5Gu_Z>RO2(

1VB#=cAZZBGUgf@5Ea##YyrOVoUSiN)2! zxiiBnjpx^5XRyi~2cZ=Xr)xNTZ`Dt+9A`O_z5U9@;aqb>Le#hr)=t!`=@S%QworNN z(Vg>Qd->bKcuVA*q>@1xw10$+7LGl(U}PpGa{Bmujps<@jE8u6wLEZqX)-`$$~X)M z?Pj#-v7um;G+qmdh1Omfpa9xAEdd#;9rM(w%o=AA0;VmYAgJ~L*h*K~3}08!V#bWH z*i!CT#w1qADQbmsgaAU0V2nUHLAYlQ8IVLvW4#edWZG$i*@%suxES7?TnPP@dR)lt z?MF*n;ax3@(Es^zFQ{AR!cKcB>~`w-H(Prj2_ldnkzn3IMM^0J)O-7Q-5BSrvwKIV zvpV)SRL1{Ao%u@{b(*^@qZW-xC51BTLHBOB(Y@Lz2F8s|`XfF`X>Wdh($|CT`po?q z9qAn0eD-2ypF diff --git a/state/ledgers.msgpack b/state/ledgers.msgpack index 5ffd6049abed4f9aadc2bf2f5a5d0dea8cdb2aef..bb9a5bd2c8aa1aa4f9b6593002ee4fab30812328 100644 GIT binary patch delta 705 zcmYLHyN=W_6lI2m6idezh+_95+Q~dJlbu%s(h9NCN`RJ%&arPc)_Ux$AM>D@0wg-R zQ96W>=#dbjrh$f%|KJz62}l%IaqQ!B&pFqxe;oe$dHCs0Yd=kA$?(PZYthHS=liXz zR_n{FUHi?h-J+_$*QxfXZcyF)x@$+j-&aSsqx~p--k;9Ww7R$1yL+qs;Y=)y8#~W@aKN;HpmWq5MbFr> zV4Bbl7fgG}fdyX}EByvml2*Y(&N3@G^U~-! z8no0G3cbq{m%&6i9M2Vi=B7D48RJy#dGz zZ7hloxIjZ)N@pyLdt)LZJn=i~z9^-7fL%BVwjq6TPJvJ!u8<{|yf$bwmkMpu{+Xbe Pc<}VHu#RcLh^G4o+JyCW delta 61 zcmca|My}%H!Cw1GBR#yp32ldm5C9EK{PWEvj8zG5VLKc J%EbPD0RVF+6Y&55 diff --git a/state/map.yaml b/state/map.yaml index 3c3991a4..b755974e 100644 --- a/state/map.yaml +++ b/state/map.yaml @@ -714,4 +714,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`. swarm overview 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: Complete the live survival proof for the workstation semantic projector service body. The shared Yggdrasil Qdrant is authoritative and reachable through the ops-owned workstation tunnel at `127.0.0.1:16333`; Yggdrasil Ollama is reachable on WireGuard at `10.77.0.1:11435`, and both Epiphany collections are green, 1024-dimensional cosine collections owned by the configured Qwen embedding model. Idunn's reserved policy now binds those endpoints and is the sole desired-state owner. Managed launch preallocates a UUID, injects it before spawn, and atomically seals an immutable v1 PID-bound launch receipt against the exact current policy envelope; a child cannot construct its service body, pulse, or heartbeat until that receipt authenticates, and failed sealing kills and waits for the child. Semantic recovery v2 accepts only the current policy -> exact launch receipt -> causally later correlated provider heartbeat chain; daemon poke receipts cannot mint claim authority. One packaged process still owns fair bounded execution across distinct same-swarm Mind and Modeling stores, with canonical grants/claims/attempts/receipts as query authority and provider health as sight only. Library proof is green (371 passed, 1 ignored), supervisor authority proof is green (7 passed), and all binaries compile. Next publish the reserved policy, place the reconciler and Qdrant tunnel under durable Idunn/OS survival ownership, then prove a real child launch and handshake, bounded pulse, provider heartbeat, both health rows, forced restart with new correlated heartbeat, exact recovery/resumption where a safe abandoned claim can be created, and host singleton refusal. Do not call deployment complete until those live proofs pass. + next_action: Finish durable survival ownership for the now-live workstation semantic projector. The reserved policy is published against Yggdrasil Qdrant at `127.0.0.1:16333` and Ollama at `10.77.0.1:11435`. Explicit migrations removed the extinct ownerless operator-status projection and retired pre-Idunn claims, attempts, and index receipts from active semantic authority without fabricating grants; current Mind and Modeling projections were rebuilt through fresh Idunn grants and are query-eligible at 1024 dimensions (43 and 3 documents). Launch receipts now bind exact policy digest, child PID, executable SHA-256, fixed provider, and startup correlation; the child checks its own PID and bytes before constructing the body. Live proof shows a clean two-source idle pulse, ready correlated heartbeat, semantic ranking for both partitions, host singleton refusal, and Idunn restart after a forced child kill from PID 22992 to 29868 with launch receipt `daa89e4f-4301-40eb-aa87-5b52c5017221` and matching ready heartbeat. Library proof is 375 passed/1 ignored, supervisor proof 7/7, all binaries compile. Remaining deployment gap: the currently detached reconciler PID 22072 and ops SSH tunnel PID 22728 are not durable OS-owned physiology. Replace the false ordinary-console `sc.exe` service path with a real service host or explicit Task Scheduler ownership and restart policy, make the Qdrant tunnel equally durable, then prove reboot/startup recovery. Exact abandoned-claim recovery is unit/hostile proved but still needs a safe live recovery fixture; do not forge canonical work merely to make the dashboard green. diff --git a/vendor/cultcache-rs b/vendor/cultcache-rs index 1383a74b..deec76be 160000 --- a/vendor/cultcache-rs +++ b/vendor/cultcache-rs @@ -1 +1 @@ -Subproject commit 1383a74becfd17f49879e574c48995b0e2b502aa +Subproject commit deec76be73548867f9276e9c3a4bdcfa265f90e0