From 7e320b5d148e817d18f27cfaae2a3dc5be773c34 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Mon, 10 Aug 2026 04:06:01 +0100 Subject: [PATCH] Register semantic retention evidence in source readers --- epiphany-core/src/agent_memory.rs | 18 +++++++++++++++ epiphany-core/src/runtime_spine.rs | 18 +++++++++++++++ notes/epiphany-current-algorithmic-map.md | 11 +++++++++ notes/fresh-workspace-handoff.md | 27 +++++++++++++++++++++++ state/map.yaml | 6 ++--- 5 files changed, 77 insertions(+), 3 deletions(-) diff --git a/epiphany-core/src/agent_memory.rs b/epiphany-core/src/agent_memory.rs index be6015bd..62206ac8 100644 --- a/epiphany-core/src/agent_memory.rs +++ b/epiphany-core/src/agent_memory.rs @@ -2534,6 +2534,7 @@ 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.add_generic_backing_store(SingleFileMessagePackBackingStore::new(store_path)); @@ -3225,6 +3226,23 @@ mod tests { assert_eq!(obligations[0].partition, "mind"); assert_eq!(obligations[0].source_generation, 1); assert!(!obligations[0].source_model_hash.is_empty()); + let scope_id = format!("{}:{}", obligations[0].swarm_id, obligations[0].partition); + cache.put( + &scope_id, + &crate::MemorySemanticProjectionRetentionHead { + schema_version: + crate::MEMORY_SEMANTIC_PROJECTION_RETENTION_HEAD_SCHEMA_VERSION.to_string(), + scope_id: scope_id.clone(), + revision: 1, + retired_generation_count: 1, + retired_envelope_count: 1, + retired_type_counts: BTreeMap::from([("test.retired".to_string(), 1)]), + retired_status_counts: BTreeMap::from([("failed".to_string(), 1)]), + retired_chain_digest: format!("sha256:{}", "0".repeat(64)), + retained_at: "2026-07-15T00:00:01Z".to_string(), + private_state_exposed: false, + }, + )?; let input = agent_memory_semantic_projection_input(&store)?; assert_eq!(input.obligation, obligations[0]); assert_eq!(input.snapshot.model_revision, 1); diff --git a/epiphany-core/src/runtime_spine.rs b/epiphany-core/src/runtime_spine.rs index e2cb49fc..531354f3 100644 --- a/epiphany-core/src/runtime_spine.rs +++ b/epiphany-core/src/runtime_spine.rs @@ -1035,6 +1035,7 @@ 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::()?; @@ -11773,6 +11774,23 @@ pub(crate) mod tests { Some(obligation.clone()) ); assert_eq!(runtime_current_repo_model(&store)?, Some(snapshot.clone())); + let scope_id = format!("{}:{}", obligation.swarm_id, obligation.partition); + cache.put( + &scope_id, + &crate::MemorySemanticProjectionRetentionHead { + schema_version: + crate::MEMORY_SEMANTIC_PROJECTION_RETENTION_HEAD_SCHEMA_VERSION.to_string(), + scope_id: scope_id.clone(), + revision: 1, + retired_generation_count: 1, + retired_envelope_count: 1, + retired_type_counts: BTreeMap::from([("test.retired".to_string(), 1)]), + retired_status_counts: BTreeMap::from([("failed".to_string(), 1)]), + retired_chain_digest: format!("sha256:{}", "0".repeat(64)), + retained_at: "2026-07-15T00:00:02Z".to_string(), + private_state_exposed: false, + }, + )?; let input = runtime_modeling_semantic_projection_input(&store)?; assert_eq!(input.snapshot, snapshot); assert_eq!(input.obligation, obligation); diff --git a/notes/epiphany-current-algorithmic-map.md b/notes/epiphany-current-algorithmic-map.md index 50dd98f9..80c78879 100644 --- a/notes/epiphany-current-algorithmic-map.md +++ b/notes/epiphany-current-algorithmic-map.md @@ -2664,3 +2664,14 @@ ready-chain preservation, and rejection of hostile future generations even inside the recent window. A warning-free production binary check covers the daemon wiring. Exact packaged copied-live proof remains the acceptance boundary; physical Qdrant epoch cleanup remains a distinct executor-owned action. + +The first exact packaged copied-state run exposed a catalog crossing omitted by +the initial map. Logical retention writes into the canonical Mind and Modeling +stores, so every general reader of those stores must recognize the evidence-head +schema even though only the retention owner may write or interpret it. The +projector cache already registered the head; `agent_memory_cache` and +`runtime_spine_cache` did not, causing current semantic input/health reads to +refuse the entire store after the first successful retirement. Both canonical +source catalogs now register the head as evidence-only. Projection-input tests +persist a head and prove current Mind and Modeling derivation remains unchanged. +This is schema legibility, not shared decision authority. diff --git a/notes/fresh-workspace-handoff.md b/notes/fresh-workspace-handoff.md index e5824320..e1c3785b 100644 --- a/notes/fresh-workspace-handoff.md +++ b/notes/fresh-workspace-handoff.md @@ -1692,3 +1692,30 @@ Next commit and push this source, package and inspect that exact commit from the persistent Starfire cache, then prove it against copied state only. Preserve active c005. Physical Qdrant epoch garbage collection and Persona conversation retirement remain later, separate ownership cuts. Yggdrasil never builds. + +## Copied-live semantic consumer fault and repair — 2026-08-10 + +Exact source `6740fc2a` packaged warning-free in 6m52s with 24 binaries as +release +`sha256-38b9153d3cad5c2460522278c1e7ce863e5b9a35499611b1f6926cc2f6937d1c` +and witness +`sha256-092d9b0f4174131705aabdf77620b196ff69ddec1affcf4d58e9a2b7a1d54593`. +Construction and inspection receipts are under +`.epiphany-run/linux-package-6740fc2a`. The first shell-wrapped launch failed +before Cargo and is preserved in `failed-state.json`; the direct authenticated +packager command succeeded. + +On copied `active-cognition6-a987d2f7` Eyes-tools state, the exact packaged +projector retired one real semantic lifecycle family with zero retention faults. +The subsequent exact packaged semantic health reader then refused the retained +runtime store because `runtime_spine_cache` did not register the typed retention +head. The corresponding `agent_memory_cache` omission had the same defect. This +was a consumer catalog integration failure, not corrupt retained state. + +The repair registers `MemorySemanticProjectionRetentionHead` in both canonical +source-store catalogs as a known evidence type. It gains no query, claim, or +readiness authority. Focused Mind and Modeling projection-input tests now place +a retention head beside the canonical source family and still derive the exact +current projection input. Both pass. Commit/push, repackage, and repeat the proof +from a pristine copy; `6740fc2a` is evidence of the caught fault, not an accepted +release. diff --git a/state/map.yaml b/state/map.yaml index 7eacab63..ad3cc841 100644 --- a/state/map.yaml +++ b/state/map.yaml @@ -36,9 +36,9 @@ invariants: current_status: summary: Epiphany is a supervised engineering alpha on Starfire, not deployment-ready. Exact b8138a6b active-child SIGTERM and restart, exact 9f369528 deterministic warm packaging, exact c930f505 cross-container ownership, exact ed15f83a resident lifecycle retention, exact 16c4b19f coordinator receipt and Heartbeat artifact retention, exact cce2b8ac narrow model-generation retention, and exact eea15e82 model-turn JSON ingress are proven. Gamecult-ops 059821f makes journald the sole Yggdrasil supervisor/projector stream-retention owner. Exact 16c4b19f genuine idle and exact a987d2f7 active cognition completed 900-pulse bounded plateaus. Runtime-owned typed fulfillment is accepted live under exact 6dd9b132. Semantic logical lifecycle retention is source-green but not yet package/live accepted; physical semantic garbage collection and Persona conversation retention remain separate. Stable Starfire firewall ownership remains open. Yggdrasil is the small public crossing body, never the release forge. - latest_phase: Semantic logical lifecycle retention now runs per canonical source scope after each projector pulse with a default 256-generation window. It preserves the exact current obligation, singleton claim, claim authority, and readiness family; refuses running or future/non-stale authority; retires only older closed generations into one typed evidence head under a full-snapshot fence. Four focused tests prove exact ready-chain preservation, running refusal, hostile future-generation refusal, stale-CAS refusal, unrelated-row identity, replay stability, and head type separation. Production projector check is warning-free. Exact packaging and copied-live proof remain open. + latest_phase: Exact 6740fc2a packaged warning-free with 24 binaries as release sha256-38b9153d3cad5c2460522278c1e7ce863e5b9a35499611b1f6926cc2f6937d1c and witness sha256-092d9b0f4174131705aabdf77620b196ff69ddec1affcf4d58e9a2b7a1d54593. Its copied-live pulse retired one real semantic lifecycle family with zero retention faults, then the packaged semantic health consumer exposed a catalog fault: agent-memory and runtime-spine caches did not register the new evidence head and refused the retained stores as unknown schema. The source repair registers the evidence type in both canonical readers; focused Mind and Modeling projection-input tests now persist a head and still derive the exact current input. Repackage/replay is required before acceptance. operational_state: - local_worktree: semantic_logical_lifecycle_retention_source_green_uncommitted + local_worktree: semantic_retention_consumer_catalog_repair_green_uncommitted operator_wireguard: restored yggdrasil: canonical_small_public_crossing_body starfire: temporary_epiphany_cognition_body @@ -69,7 +69,7 @@ current_status: yggdrasil_epiphany_service_contract: repaired_in_gamecult_ops_812b427_not_installed resident_physiology: authenticated_9b8df0b4_c005_bound_to_eyes_tools_nervous_system_with_217dd_and_bd96305e_helpers_running unresolved_authority: Coordinator receipt, Heartbeat pulse-artifact, deployed supervisor/projector log retention, genuine-idle and active resource plateaus, exact-grant terminality, restart-persistent cooldown refusal, schedule/action issuance cardinality, runtime-owned typed fulfillment, narrow model-generation retention, and published model-turn JSON ingress are accepted. Semantic logical lifecycle retention is source-green but lacks exact packaged copied-live proof. Physical Qdrant epochs and conversation-wide runtime histories remain separate/unbounded. Repository Body observation still performs two authenticated full-tree Git index/manifest passes. Execute-mode workers require a persistent process body. Keyed storage has not earned live migration. One Discord consequence remains blocked by the absent Yggdrasil credential. - next_action: Commit and push semantic logical lifecycle retention, package and authenticate that exact source from Starfire's persistent cache, then exercise only copied state. Prove exact old lifecycle retirement, current query/readiness identity, unrelated-row byte identity, stable replay, and that the typed head cannot open readiness, acquire a claim, or resurrect work. Physical Qdrant epoch GC and cross-store Persona conversation retirement remain separate following cuts. Preserve active c005. Yggdrasil never builds. + next_action: Commit and push the semantic retention consumer-catalog repair, package and authenticate that exact source from Starfire's persistent cache, then repeat the copied-state proof from a pristine copy. Require one real retirement, readable and identical current Mind/Modeling projection inputs after the head exists, zero-mutation stable replay, and no readiness/claim resurrection. Physical Qdrant epoch GC and cross-store Persona conversation retirement remain separate following cuts. Preserve active c005. Yggdrasil never builds. active_subgoals: - Prove Persona, Self, Eyes, Modeling, Imagination, Hands, Soul, Mind, Continuity, and nervous-system behavior individually.