From 868a5be070138645d492ccb3f514aa5d49e03d8a Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Wed, 12 Aug 2026 01:44:00 +0200 Subject: [PATCH] Consolidate causal identity ownership --- .../admitted_model_direction_consideration.rs | 10 +- epiphany-core/src/causal_work_identity.rs | 93 + epiphany-core/src/coordinator_launch.rs | 47 +- epiphany-core/src/lib.rs | 4 + epiphany-core/src/public_source_identity.rs | 152 + epiphany-core/src/runtime_spine.rs | 146 +- .../src/native_public.rs | 64 +- notes/epiphany-current-algorithmic-map.md | 22 + notes/fresh-workspace-handoff.md | 4204 +---------------- notes/perfect-machine-audit-roadmap.md | 179 +- state/ledgers.msgpack | Bin 618360 -> 618834 bytes state/map.yaml | 6 +- 12 files changed, 488 insertions(+), 4439 deletions(-) create mode 100644 epiphany-core/src/causal_work_identity.rs create mode 100644 epiphany-core/src/public_source_identity.rs diff --git a/epiphany-core/src/admitted_model_direction_consideration.rs b/epiphany-core/src/admitted_model_direction_consideration.rs index 7ba07c5b..4c81a24c 100644 --- a/epiphany-core/src/admitted_model_direction_consideration.rs +++ b/epiphany-core/src/admitted_model_direction_consideration.rs @@ -137,17 +137,11 @@ pub fn commit_request( return Ok(None); } let previous_terminal_result_id = terminal.last().map(|result| result.result_id.clone()); - let causal = rmp_serde::to_vec_named(&( + let request_id = crate::admitted_model_direction_request_id( &identity.runtime_id, - &thread.thread_id, - model.model_revision, &model_hash, &receipts[0].receipt_id, - &previous_terminal_result_id, - ))?; - let request_id = format!( - "admitted-model-direction-consideration-{:x}", - Sha256::digest(causal) + previous_terminal_result_id.as_deref(), ); let request = AdmittedModelDirectionConsiderationRequest { schema_version: REQUEST_SCHEMA.into(), diff --git a/epiphany-core/src/causal_work_identity.rs b/epiphany-core/src/causal_work_identity.rs new file mode 100644 index 00000000..5bf9f37c --- /dev/null +++ b/epiphany-core/src/causal_work_identity.rs @@ -0,0 +1,93 @@ +use sha2::{Digest, Sha256}; + +fn digest_id(prefix: &str, causal_parts: &[&str]) -> String { + let mut digest = Sha256::new(); + for part in causal_parts { + digest.update((part.len() as u64).to_be_bytes()); + digest.update(part.as_bytes()); + } + format!("{prefix}-{:x}", digest.finalize()) +} + +pub fn proposal_modeling_request_id( + runtime_id: &str, + proposal_id: &str, + payload_sha256: &str, +) -> String { + digest_id( + "repo-frontier-proposal-modeling", + &[runtime_id, proposal_id, payload_sha256], + ) +} + +pub fn frontier_research_request_id( + runtime_id: &str, + model_hash: &str, + frontier_item_hash: &str, +) -> String { + digest_id( + "repo-frontier-research", + &[runtime_id, model_hash, frontier_item_hash], + ) +} + +pub fn frontier_planning_request_id( + runtime_id: &str, + model_hash: &str, + frontier_item_hash: &str, +) -> String { + digest_id( + "repo-frontier-planning", + &[runtime_id, model_hash, frontier_item_hash], + ) +} + +pub fn frontier_plan_mind_request_id( + runtime_id: &str, + planning_request_id: &str, + imagination_result_id: &str, + candidate_sha256: &str, +) -> String { + digest_id( + "repo-frontier-plan-mind", + &[ + runtime_id, + planning_request_id, + imagination_result_id, + candidate_sha256, + ], + ) +} + +pub fn admitted_model_direction_request_id( + runtime_id: &str, + model_hash: &str, + admission_receipt_id: &str, + previous_terminal_result_id: Option<&str>, +) -> String { + digest_id( + "admitted-model-direction-consideration", + &[ + runtime_id, + model_hash, + admission_receipt_id, + previous_terminal_result_id.unwrap_or(""), + ], + ) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn provenance_does_not_participate_in_causal_identity() { + let first = frontier_research_request_id("runtime", "model", "frontier"); + let after_thread_transition = frontier_research_request_id("runtime", "model", "frontier"); + assert_eq!(first, after_thread_transition); + assert_ne!( + first, + frontier_research_request_id("runtime", "model", "other") + ); + } +} diff --git a/epiphany-core/src/coordinator_launch.rs b/epiphany-core/src/coordinator_launch.rs index 7d5abb31..9fcfb3a5 100644 --- a/epiphany-core/src/coordinator_launch.rs +++ b/epiphany-core/src/coordinator_launch.rs @@ -56,6 +56,11 @@ fn commit_coordinator_job_launch_in_cache( "coordinator commit thread id must match typed launch document" )); } + if let Some(admitted_thread) = cache.get::(crate::THREAD_STATE_KEY)? { + if admitted_thread.thread_id != thread_id || admitted_thread.state()? != *current_state { + return Err(anyhow!("coordinator launch carrier must use the current admitted thread")); + } + } let runtime_identity = cache .get::(RUNTIME_IDENTITY_KEY)? .ok_or_else(|| anyhow!("coordinator launch requires runtime identity"))?; @@ -742,8 +747,8 @@ fn validate_frontier_plan_mind_launch( .ok_or_else(|| anyhow!("Mind launch requires thread state"))?; if persisted.state()? != *state || request.runtime_id != identity.runtime_id - || request.thread_id != persisted.thread_id - || launch.launch_document.thread_id() != request.thread_id + || request.thread_id.is_empty() + || launch.launch_document.thread_id() != persisted.thread_id { return Err(anyhow!("Mind launch provenance mismatch")); } @@ -848,9 +853,8 @@ fn validate_frontier_planning_launch( let persisted_state_value = persisted_state.state()?; if planning.request_id != request_id || planning.runtime_id != identity.runtime_id - || planning.thread_id != persisted_state.thread_id || persisted_state_value != *state - || launch.launch_document.thread_id() != planning.thread_id + || launch.launch_document.thread_id() != persisted_state.thread_id { return Err(anyhow!( "frontier planning launch provenance binding mismatch" @@ -954,9 +958,9 @@ fn validate_imagination_consideration_launch( .get::(crate::THREAD_STATE_KEY)? .ok_or_else(|| anyhow!("consideration requires thread state"))?; if request.runtime_id != identity.runtime_id - || request.thread_id != persisted.thread_id + || request.thread_id.is_empty() || persisted.state()? != *state - || launch.launch_document.thread_id() != request.thread_id + || launch.launch_document.thread_id() != persisted.thread_id { return Err(anyhow!("consideration launch provenance mismatch")); } @@ -1019,9 +1023,9 @@ fn validate_admitted_model_direction_consideration_launch( .get::(crate::THREAD_STATE_KEY)? .ok_or_else(|| anyhow!("model direction consideration requires thread state"))?; if request.runtime_id != identity.runtime_id - || request.thread_id != persisted.thread_id + || request.thread_id.is_empty() || persisted.state()? != *state - || launch.launch_document.thread_id() != request.thread_id + || launch.launch_document.thread_id() != persisted.thread_id { return Err(anyhow!("model direction consideration provenance mismatch")); } @@ -2111,7 +2115,7 @@ pub(crate) mod tests { } #[test] - fn proposal_launch_restores_its_admitted_thread_after_resident_projection_transition( + fn proposal_launch_cannot_restore_superseded_thread_authority( ) -> Result<()> { let root = tempfile::tempdir()?; let (store, state, request, selection) = @@ -2129,27 +2133,17 @@ pub(crate) mod tests { "launcher-after-transition".into(), "backend-after-transition".into(), )?; - let committed = commit_coordinator_job_launch( + let before = std::fs::read(&store)?; + let error = commit_coordinator_job_launch( &store, &selection.thread_id, &state, &request, &plan, "2026-07-13T05:00:04Z".into(), - )?; - - let cache = coordinator_acceptance_cache(&store)?; - let restored = cache - .get::(THREAD_STATE_KEY)? - .expect("launch restores admitted cognitive thread projection"); - assert_eq!(restored.thread_id, selection.thread_id); - assert_eq!(restored.state()?, committed.epiphany_state); - let binding = cache - .get::( - "repo-frontier-proposal-modeling-launch-backend-after-transition", - )? - .expect("launch preserves admitted proposal lineage"); - assert_eq!(binding.thread_id, selection.thread_id); + ).expect_err("superseded provenance cannot rewrite the admitted carrier thread"); + assert!(error.to_string().contains("current admitted thread")); + assert_eq!(std::fs::read(&store)?, before); Ok(()) } @@ -2743,7 +2737,7 @@ pub(crate) mod tests { #[test] fn frontier_planning_launch_refuses_swapped_request_bytes_without_writes() -> Result<()> { let root = tempfile::tempdir()?; - for mutation in 0..8 { + for mutation in 0..7 { let (store, state, launch, planning) = frontier_planning_launch_fixture(root.path(), &format!("causal-{mutation}"))?; let mut corrupt = planning.clone(); @@ -2754,8 +2748,7 @@ pub(crate) mod tests { 3 => corrupt.frontier_item_hash = "swapped-frontier-hash".into(), 4 => corrupt.selected_organ = "Hands".into(), 5 => corrupt.source_scope.push("outside/scope".into()), - 6 => corrupt.runtime_id = "swapped-runtime".into(), - _ => corrupt.thread_id = "swapped-thread".into(), + _ => corrupt.runtime_id = "swapped-runtime".into(), } let mut cache = coordinator_acceptance_cache(&store)?; cache.put(&corrupt.request_id, &corrupt)?; diff --git a/epiphany-core/src/lib.rs b/epiphany-core/src/lib.rs index 0b4983f0..41ab28ee 100644 --- a/epiphany-core/src/lib.rs +++ b/epiphany-core/src/lib.rs @@ -1,6 +1,7 @@ mod agent_launch; mod agent_memory; mod agent_utterance_state; +mod causal_work_identity; mod continuity_gateway; mod coordinator_acceptance; mod coordinator_interrupt; @@ -33,6 +34,7 @@ mod persona_feedback_admission; mod persona_turn; mod process_observation; mod promotion; +mod public_source_identity; mod prompt_context; mod proposal; mod repo_model_gateway; @@ -189,6 +191,7 @@ pub use agent_utterance_state::AgentUtterancePersonalityVectors; pub use agent_utterance_state::AgentUtteranceState; pub use agent_utterance_state::AgentUtteranceValue; pub use agent_utterance_state::WEKSA_UTTERANCE_HANDOFF_SCHEMA_VERSION; +pub use causal_work_identity::*; pub use agent_utterance_state::derive_agent_utterance_state; pub use continuity_gateway::*; pub use coordinator_acceptance::EpiphanyAcceptancePrerequisite; @@ -967,6 +970,7 @@ pub use process_observation::observe_native_process; pub use process_observation::observe_process_instance; pub use process_observation::reap_exited_child_process; pub use process_observation::terminate_process_instance; +pub use public_source_identity::ImmutableGithubSource; pub use promotion::EpiphanyPromotionDecision; pub use promotion::EpiphanyPromotionInput; pub use promotion::EpiphanyStateReplacementValidationInput; diff --git a/epiphany-core/src/public_source_identity.rs b/epiphany-core/src/public_source_identity.rs new file mode 100644 index 00000000..b57e7e5a --- /dev/null +++ b/epiphany-core/src/public_source_identity.rs @@ -0,0 +1,152 @@ +use anyhow::{Result, anyhow}; +use std::fmt::{Display, Formatter}; + +#[derive(Clone, Debug, Eq, PartialEq, Ord, PartialOrd)] +pub struct ImmutableGithubSource { + owner: String, + repository: String, + revision: String, + path: String, +} + +impl ImmutableGithubSource { + pub fn from_components( + owner: &str, + repository: &str, + revision: &str, + path: &str, + ) -> Result { + validate_component(owner, "owner")?; + validate_component(repository, "repository")?; + if revision.len() != 40 || !revision.bytes().all(|byte| byte.is_ascii_hexdigit()) { + return Err(anyhow!( + "GitHub revision must be an immutable 40-hex commit id" + )); + } + validate_path(path)?; + Ok(Self { + owner: owner.into(), + repository: repository.into(), + revision: revision.to_ascii_lowercase(), + path: path.into(), + }) + } + + pub fn parse(source_ref: &str) -> Result { + let rest = source_ref + .strip_prefix("github://") + .ok_or_else(|| anyhow!("immutable GitHub source must use github://"))?; + let (repository_identity, target) = rest + .split_once('@') + .ok_or_else(|| anyhow!("immutable GitHub source requires an exact revision"))?; + if target.contains('@') { + return Err(anyhow!( + "immutable GitHub source contains multiple revisions" + )); + } + let (owner, repository) = repository_identity + .split_once('/') + .ok_or_else(|| anyhow!("immutable GitHub source requires owner/repository"))?; + if repository.contains('/') { + return Err(anyhow!("immutable GitHub repository identity is not exact")); + } + let (revision, path) = target + .split_once('/') + .ok_or_else(|| anyhow!("immutable GitHub source requires a repository path"))?; + Self::from_components(owner, repository, revision, path) + } + + pub fn owner(&self) -> &str { + &self.owner + } + pub fn repository_name(&self) -> &str { + &self.repository + } + pub fn revision(&self) -> &str { + &self.revision + } + pub fn path(&self) -> &str { + &self.path + } + pub fn repository_ref(&self) -> String { + format!("github://{}/{}", self.owner, self.repository) + } +} + +impl Display for ImmutableGithubSource { + fn fmt(&self, formatter: &mut Formatter<'_>) -> std::fmt::Result { + write!( + formatter, + "{}@{}/{}", + self.repository_ref(), + self.revision, + self.path + ) + } +} + +fn validate_component(value: &str, name: &str) -> Result<()> { + if value.is_empty() + || value.len() > 100 + || !value + .bytes() + .all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'-' | b'_' | b'.')) + { + return Err(anyhow!("GitHub {name} is invalid")); + } + Ok(()) +} + +fn validate_path(path: &str) -> Result<()> { + if path.is_empty() + || path.len() > 512 + || path.starts_with('/') + || path.split('/').any(|segment| { + segment.is_empty() + || matches!(segment, "." | "..") + || !segment + .bytes() + .all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'-' | b'_' | b'.')) + }) + { + return Err(anyhow!("GitHub repository path is invalid")); + } + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn canonicalizes_and_round_trips() -> Result<()> { + let source = ImmutableGithubSource::from_components( + "GameCult", + "Epiphany", + "ABCDEF0123456789ABCDEF0123456789ABCDEF01", + "docs/source_file.rs", + )?; + assert_eq!( + source.revision(), + "abcdef0123456789abcdef0123456789abcdef01" + ); + assert_eq!(ImmutableGithubSource::parse(&source.to_string())?, source); + Ok(()) + } + + #[test] + fn refuses_mutable_or_ambiguous_identity() { + for source_ref in [ + "https://github.com/GameCult/Epiphany", + "github://GameCult/Epiphany@main/README.md", + "github://GameCult/Epiphany@0123456789abcdef0123456789abcdef01234567/../secret", + "github://GameCult/Epiphany@0123456789abcdef0123456789abcdef01234567//secret", + "github://GameCult/other/repo@0123456789abcdef0123456789abcdef01234567/file", + ] { + assert!( + ImmutableGithubSource::parse(source_ref).is_err(), + "{source_ref}" + ); + } + } +} diff --git a/epiphany-core/src/runtime_spine.rs b/epiphany-core/src/runtime_spine.rs index 1baf8118..5ef068e7 100644 --- a/epiphany-core/src/runtime_spine.rs +++ b/epiphany-core/src/runtime_spine.rs @@ -3736,20 +3736,22 @@ pub(crate) fn authenticated_public_source_lookups_for_worker( .ok_or_else(|| anyhow!("public source receipt has no result"))?, ) .context("public source receipt result is invalid")?; - let owner = public_source_json_string(&arguments, "owner")?; - let repository_name = public_source_json_string(&arguments, "repository")?; - let revision = public_source_json_string(&arguments, "revision")?.to_ascii_lowercase(); - let path = public_source_json_string(&arguments, "path")?; + let source = crate::ImmutableGithubSource::from_components( + public_source_json_string(&arguments, "owner")?, + public_source_json_string(&arguments, "repository")?, + public_source_json_string(&arguments, "revision")?, + public_source_json_string(&arguments, "path")?, + )?; let content = public_source_json_string(&result, "content")?; - let repository = format!("github://{owner}/{repository_name}"); - let source_ref = format!("{repository}@{revision}/{path}"); + let repository = source.repository_ref(); + let source_ref = source.to_string(); let content_sha256 = format!("{:x}", Sha256::digest(content.as_bytes())); let byte_count = content.len() as u64; let lookup_receipt_id = format!("eyes-source-{}", intent.intent_id); if public_source_json_string(&result, "provider")? != "github" || public_source_json_string(&result, "repository")? != repository - || public_source_json_string(&result, "revision")? != revision - || public_source_json_string(&result, "path")? != path + || public_source_json_string(&result, "revision")? != source.revision() + || public_source_json_string(&result, "path")? != source.path() || public_source_json_string(&result, "sourceRef")? != source_ref || public_source_json_string(&result, "contentSha256")? != content_sha256 || result.get("byteCount").and_then(serde_json::Value::as_u64) @@ -3767,8 +3769,8 @@ pub(crate) fn authenticated_public_source_lookups_for_worker( tool_receipt_id: receipt.receipt_id, provider: "github".to_string(), repository, - revision, - path: path.to_string(), + revision: source.revision().to_string(), + path: source.path().to_string(), source_ref, content_sha256, byte_count, @@ -4811,10 +4813,6 @@ fn validate_proposal_modeling_worker_fulfillment( EpiphanyWorkerLaunchDocument::Reorient(_) => None, }; let identity = require_identity(cache)?; - let thread = cache - .get::(crate::THREAD_STATE_KEY)? - .ok_or_else(|| anyhow!("proposal Modeling fulfillment thread state is missing"))?; - thread.state()?; let payload = rmp_serde::to_vec_named(&( &proposal.title, &proposal.body, @@ -4853,12 +4851,13 @@ fn validate_proposal_modeling_worker_fulfillment( "request.payload", request.proposal_payload_sha256 != proposal.payload_sha256, ), + ("request.identity", request.request_id != crate::proposal_modeling_request_id(&request.runtime_id, &request.proposal_id, &request.proposal_payload_sha256)), ( "proposal.payload", proposal.payload_sha256 != proposal_payload_sha256, ), ("request.runtime", request.runtime_id != identity.runtime_id), - ("request.thread", request.thread_id != thread.thread_id), + ("request.thread", request.thread_id != proposal.thread_id), ( "request.repository", request.repository != proposal.repository, @@ -4895,7 +4894,7 @@ fn validate_proposal_modeling_worker_fulfillment( binding.binding_id != EPIPHANY_MODELING_ROLE_BINDING_ID, ), ("binding.runtime", binding.runtime_id != identity.runtime_id), - ("binding.thread", binding.thread_id != thread.thread_id), + ("binding.thread", binding.thread_id != request.thread_id), ( "binding.time", chrono::DateTime::parse_from_rfc3339(&binding.launched_at).is_err(), @@ -6738,10 +6737,7 @@ pub fn promote_autonomous_direction_options_for_modeling( }; let selection = RepoFrontierProposalModelingRequest { schema_version: REPO_FRONTIER_PROPOSAL_MODELING_REQUEST_SCHEMA_VERSION.into(), - request_id: format!( - "repo-frontier-proposal-modeling-{:x}", - Sha256::digest(format!("{}:{}", proposal_id, payload_sha256).as_bytes()) - ), + request_id: crate::proposal_modeling_request_id(&identity.runtime_id, &proposal_id, &payload_sha256), proposal_id: proposal_id.clone(), proposal_payload_sha256: payload_sha256, runtime_id: identity.runtime_id.clone(), @@ -6959,10 +6955,7 @@ pub fn select_repo_frontier_work_proposal_for_modeling( if proposal.source_kind == crate::RepoFrontierProposalSourceKind::Imagination { validate_autonomous_proposal_binding(&cache, &proposal)?; } - let thread = cache - .get::(crate::THREAD_STATE_KEY)? - .ok_or_else(|| anyhow!("proposal selection requires authoritative thread state"))?; - if proposal.runtime_id != identity.runtime_id || proposal.thread_id != thread.thread_id { + if proposal.runtime_id != identity.runtime_id { return Err(anyhow!("proposal selection provenance mismatch")); } let existing_requests = cache.get_all::()?; @@ -6978,10 +6971,7 @@ pub fn select_repo_frontier_work_proposal_for_modeling( return Err(anyhow!("proposal already incorporated")); } } - let request_id = format!( - "repo-frontier-proposal-modeling-{:x}", - Sha256::digest(format!("{}:{}", proposal.proposal_id, proposal.payload_sha256).as_bytes()) - ); + let request_id = crate::proposal_modeling_request_id(&proposal.runtime_id, &proposal.proposal_id, &proposal.payload_sha256); let request = RepoFrontierProposalModelingRequest { schema_version: REPO_FRONTIER_PROPOSAL_MODELING_REQUEST_SCHEMA_VERSION.into(), request_id: request_id.clone(), @@ -7064,16 +7054,7 @@ pub fn select_and_commit_repo_frontier_planning_request( let item = actionable_imagination_frontier_item(&model, &challenges) .ok_or_else(|| anyhow!("planning requires an actionable Imagination frontier"))?; let item_hash = format!("{:x}", Sha256::digest(rmp_serde::to_vec_named(item)?)); - let request_id = format!( - "repo-frontier-planning-{:x}", - Sha256::digest( - format!( - "{}:{}:{model_hash}:{}:{item_hash}", - identity.runtime_id, thread.thread_id, item.id - ) - .as_bytes(), - ) - ); + let request_id = crate::frontier_planning_request_id(&identity.runtime_id, &model_hash, &item_hash); if cache .get_all::()? .iter() @@ -7162,16 +7143,7 @@ pub(crate) fn validate_current_repo_frontier_planning_request( let item = actionable_imagination_frontier_item(&model, &challenges) .ok_or_else(|| anyhow!("planning request frontier is no longer actionable"))?; let item_hash = format!("{:x}", Sha256::digest(rmp_serde::to_vec_named(item)?)); - let expected_request_id = format!( - "repo-frontier-planning-{:x}", - Sha256::digest( - format!( - "{}:{}:{model_hash}:{}:{item_hash}", - identity.runtime_id, thread.thread_id, item.id - ) - .as_bytes(), - ) - ); + let expected_request_id = crate::frontier_planning_request_id(&identity.runtime_id, &model_hash, &item_hash); if request.schema_version != REPO_FRONTIER_PLANNING_REQUEST_SCHEMA_VERSION || request.contract != REPO_FRONTIER_PLANNING_CONTRACT || request.request_id != expected_request_id @@ -7183,10 +7155,10 @@ pub(crate) fn validate_current_repo_frontier_planning_request( || request.selected_organ != "Imagination" || request.source_scope != item.source_scope || request.runtime_id != identity.runtime_id - || request.thread_id != thread.thread_id + || request.thread_id.is_empty() { return Err(anyhow!( - "planning request does not exactly bind current model, frontier, runtime, and thread" + "planning request does not exactly bind current model, frontier, and runtime" )); } Ok(()) @@ -7227,16 +7199,7 @@ pub fn commit_repo_frontier_plan_mind_request( validate_current_repo_frontier_planning_request(&cache, &planning)?; validate_repo_frontier_plan_candidate_against_request(&cache, &candidate, &planning)?; let candidate_sha256 = format!("{:x}", Sha256::digest(rmp_serde::to_vec_named(&candidate)?)); - let request_id = format!( - "repo-frontier-plan-mind-{:x}", - Sha256::digest( - format!( - "{}:{}:{}:{}", - planning.runtime_id, planning.thread_id, result.result_id, candidate_sha256 - ) - .as_bytes() - ) - ); + let request_id = crate::frontier_plan_mind_request_id(&planning.runtime_id, &planning.request_id, &result.result_id, &candidate_sha256); let request = RepoFrontierPlanMindRequest { schema_version: REPO_FRONTIER_PLAN_MIND_REQUEST_SCHEMA_VERSION.into(), request_id: request_id.clone(), @@ -8741,18 +8704,12 @@ pub fn select_and_commit_repo_frontier_research_request( let mut public_source_refs = item .evidence_refs .iter() - .filter(|source_ref| immutable_github_source_ref(source_ref)) - .cloned() + .filter_map(|source_ref| crate::ImmutableGithubSource::parse(source_ref).ok()) + .map(|source| source.to_string()) .collect::>(); public_source_refs.sort(); public_source_refs.dedup(); - let request_id = format!( - "repo-frontier-research-{:x}", - Sha256::digest( - format!("{}:{}:{item_hash}", identity.runtime_id, model_hash) - .as_bytes() - ) - ); + let request_id = crate::frontier_research_request_id(&identity.runtime_id, &model_hash, &item_hash); let request = RepoFrontierResearchRequest { schema_version: REPO_FRONTIER_RESEARCH_REQUEST_SCHEMA_VERSION.to_string(), request_id: request_id.clone(), @@ -8874,18 +8831,12 @@ fn repo_frontier_research_request_is_current( let mut expected_public_source_refs = item .evidence_refs .iter() - .filter(|source_ref| immutable_github_source_ref(source_ref)) - .cloned() + .filter_map(|source_ref| crate::ImmutableGithubSource::parse(source_ref).ok()) + .map(|source| source.to_string()) .collect::>(); expected_public_source_refs.sort(); expected_public_source_refs.dedup(); - let expected_request_id = format!( - "repo-frontier-research-{:x}", - Sha256::digest( - format!("{}:{}:{item_hash}", identity.runtime_id, model_hash) - .as_bytes() - ) - ); + let expected_request_id = crate::frontier_research_request_id(&identity.runtime_id, &model_hash, &item_hash); let admission_count = cache .get_all::()? .into_iter() @@ -10681,43 +10632,6 @@ fn safe_sorted_unique_paths(paths: &[String]) -> bool { }) } -fn immutable_github_source_ref(source_ref: &str) -> bool { - let Some(rest) = source_ref.strip_prefix("github://") else { - return false; - }; - let Some((owner, rest)) = rest.split_once('/') else { - return false; - }; - let Some((repository, revision_and_path)) = rest.split_once('@') else { - return false; - }; - let Some((revision, path)) = revision_and_path.split_once('/') else { - return false; - }; - let repository_component = |value: &str| { - !value.is_empty() - && value.len() <= 100 - && value.bytes().all(|byte| { - byte.is_ascii_alphanumeric() || matches!(byte, b'-' | b'_' | b'.') - }) - }; - repository_component(owner) - && repository_component(repository) - && revision.len() == 40 - && revision - .bytes() - .all(|byte| byte.is_ascii_digit() || matches!(byte, b'a'..=b'f')) - && !path.is_empty() - && path.len() <= 512 - && path.split('/').all(|segment| { - !segment.is_empty() - && !matches!(segment, "." | "..") - && segment.bytes().all(|byte| { - byte.is_ascii_alphanumeric() || matches!(byte, b'-' | b'_' | b'.') - }) - }) -} - fn validate_hands_consequence_grant( store_path: &Path, intent_id: &str, @@ -16430,9 +16344,9 @@ pub(crate) mod tests { "2026-07-13T02:02:00Z", )?; let mut second = first.clone(); - second.request_id = "repo-frontier-proposal-modeling-queued-second".into(); second.proposal_id = "queued-second-proposal".into(); second.proposal_payload_sha256 = "22".repeat(32); + second.request_id = crate::proposal_modeling_request_id(&second.runtime_id, &second.proposal_id, &second.proposal_payload_sha256); second.selected_at = "2026-07-13T02:03:00Z".into(); validate_repo_frontier_proposal_modeling_request(&second)?; overwrite_test_entry(&store, &second.request_id, &second)?; diff --git a/epiphany-tool-mcp-runtime/src/native_public.rs b/epiphany-tool-mcp-runtime/src/native_public.rs index 2275a79b..829f938e 100644 --- a/epiphany-tool-mcp-runtime/src/native_public.rs +++ b/epiphany-tool-mcp-runtime/src/native_public.rs @@ -1,4 +1,5 @@ use anyhow::{Context, Result, anyhow}; +use epiphany_core::ImmutableGithubSource; use epiphany_tool_adapter::EpiphanyToolInvocationIntent; use reqwest::redirect::Policy; use serde_json::{Value, json}; @@ -20,16 +21,12 @@ pub async fn execute_epiphany_public(intent: &EpiphanyToolInvocationIntent) -> R } async fn github_file(intent: &EpiphanyToolInvocationIntent, arguments: &Value) -> Result { - let owner = repository_component(arguments, "owner")?; - let repository = repository_component(arguments, "repository")?; - let revision = required_string(arguments, "revision")?; - if revision.len() != 40 || !revision.bytes().all(|byte| byte.is_ascii_hexdigit()) { - return Err(anyhow!( - "github_file revision must be an immutable 40-hex commit id" - )); - } - let path = required_string(arguments, "path")?; - validate_repository_path(path)?; + let source = ImmutableGithubSource::from_components( + required_string(arguments, "owner")?, + required_string(arguments, "repository")?, + required_string(arguments, "revision")?, + required_string(arguments, "path")?, + )?; let maximum = arguments .get("maxBytes") .map(|value| { @@ -40,8 +37,7 @@ async fn github_file(intent: &EpiphanyToolInvocationIntent, arguments: &Value) - .transpose()? .unwrap_or(32_768) .clamp(512, MAX_PUBLIC_SOURCE_BYTES as u64) as usize; - let revision = revision.to_ascii_lowercase(); - let url = format!("https://raw.githubusercontent.com/{owner}/{repository}/{revision}/{path}"); + let url = format!("https://raw.githubusercontent.com/{}/{}/{}/{}", source.owner(), source.repository_name(), source.revision(), source.path()); let client = reqwest::Client::builder() .redirect(Policy::none()) .no_proxy() @@ -83,10 +79,10 @@ async fn github_file(intent: &EpiphanyToolInvocationIntent, arguments: &Value) - let evidence_receipt_id = format!("eyes-source-{}", intent.intent_id); Ok(json!({ "provider": "github", - "repository": format!("github://{owner}/{repository}"), - "revision": revision, - "path": path, - "sourceRef": format!("github://{owner}/{repository}@{revision}/{path}"), + "repository": source.repository_ref(), + "revision": source.revision(), + "path": source.path(), + "sourceRef": source.to_string(), "contentSha256": content_sha256, "evidenceReceiptId": evidence_receipt_id, "byteCount": bytes.len(), @@ -94,34 +90,6 @@ async fn github_file(intent: &EpiphanyToolInvocationIntent, arguments: &Value) - })) } -fn repository_component<'a>(arguments: &'a Value, name: &str) -> Result<&'a str> { - let value = required_string(arguments, name)?; - if value.len() > 100 - || !value - .bytes() - .all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'-' | b'_' | b'.')) - { - return Err(anyhow!("github_file {name} is invalid")); - } - Ok(value) -} - -fn validate_repository_path(path: &str) -> Result<()> { - if path.len() > 512 - || path.starts_with('/') - || path.split('/').any(|segment| { - segment.is_empty() - || matches!(segment, "." | "..") - || !segment - .bytes() - .all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'-' | b'_' | b'.')) - }) - { - return Err(anyhow!("github_file path is invalid")); - } - Ok(()) -} - fn required_string<'a>(value: &'a Value, name: &str) -> Result<&'a str> { value .get(name) @@ -142,10 +110,10 @@ mod tests { "revision": "0123456789abcdef0123456789abcdef01234567", "path": "openapi.yaml" }); - assert_eq!(repository_component(&valid, "owner").unwrap(), "openai"); - assert!(validate_repository_path("docs/source_file.rs").is_ok()); - assert!(validate_repository_path("../secret").is_err()); - assert!(validate_repository_path("path with spaces").is_err()); + let revision = valid["revision"].as_str().unwrap(); + assert!(ImmutableGithubSource::from_components("openai", "openai-openapi", revision, "docs/source_file.rs").is_ok()); + assert!(ImmutableGithubSource::from_components("openai", "openai-openapi", revision, "../secret").is_err()); + assert!(ImmutableGithubSource::from_components("openai", "openai-openapi", revision, "path with spaces").is_err()); } #[tokio::test] diff --git a/notes/epiphany-current-algorithmic-map.md b/notes/epiphany-current-algorithmic-map.md index c34ea918..e73d45e6 100644 --- a/notes/epiphany-current-algorithmic-map.md +++ b/notes/epiphany-current-algorithmic-map.md @@ -1,5 +1,27 @@ # Epiphany Current Algorithmic Map +## Causal work identity and creation provenance + +- Owner: `causal_work_identity` derives durable request identity for Proposal Modeling, Research, frontier Planning, PlanMind, and Admitted Model Direction. +- Inputs: runtime identity plus the immutable admitted cause specific to each typed family. Proposal content, model/frontier hashes, accepted result identity, candidate digest, and Mind admission receipts may participate. Coordinator thread and timestamps may not. +- Outputs: deterministic typed request IDs consumed by direct and resident launch paths. +- Derived state: creation thread and request time are provenance. Job, process, grant, model-execution, and tool IDs identify attempts beneath the request and cannot redefine it. +- Forbidden writers: current coordinator thread, resident projection, retry path, launch callback, and worker output cannot fork, invalidate, or restore a request identity. +- Shared paths: a request may cross coordinator incarnations while the current admitted thread carries transport. Launch refuses byte-identically if stale provenance attempts to replace that carrier thread. +- Cut line: family-local causal hash formulas and downstream thread-restoration behavior are removed. Distinct request structs remain explicit; this is a shared invariant, not a stringly request registry. +- Verification layer: full core tests cover direct/resident generation, hostile causal substitution, current-thread transport, and byte-identical stale-thread refusal. + +## Immutable public source identity + +- Owner: `ImmutableGithubSource` owns component validation, composite parsing, lowercase revision canonicalization, repository/source rendering, and round-trip identity. +- Inputs: GitHub owner, repository, exact 40-hex commit, and bounded canonical repository path. +- Outputs: one typed identity used by Modeling source selection, Eyes provider execution, and Mind receipt authentication. +- Derived state: raw-content URL and receipt display fields. Network policy, grant authorization, content bounds, digest verification, and receipt lifecycle remain with their existing owners. +- Forbidden writers: provider output and mutually consistent JSON fields cannot define or weaken immutable source identity. +- Shared paths: uppercase provider input canonicalizes to the same lowercase source reference that Modeling stores and Mind authenticates. +- Cut line: the runtime-only composite parser and provider-local component/path validators are deleted. +- Verification layer: typed table tests reject mutable revisions, ambiguous repositories, traversal, empty segments, and invalid characters; governed public-tool tests still prove exact grant and receipt binding. + ## Heartbeat pulse-artifact retention ownership - Owner: heartbeat Continuity owns retirement of its own closed `pulse-NNNNNN` artifact directories. Status display limits and Idunn process supervision own no deletion authority. diff --git a/notes/fresh-workspace-handoff.md b/notes/fresh-workspace-handoff.md index a8239321..de55e7b6 100644 --- a/notes/fresh-workspace-handoff.md +++ b/notes/fresh-workspace-handoff.md @@ -1,4108 +1,100 @@ # Fresh workspace handoff -## Public Eyes evidence is grant-bound and Mind-admissible - 2026-08-11 - -Latest pushed source is exact `d7b199e5`; a corrected causal Eyes-frontier owner -cut is implemented locally. The full core library passes 680/680 with one -intentional helper ignored, Self-policy passes 24/24, and the OpenAI runtime -passes 39/39 across library and both binary surfaces. Actual c011 remains exact -`465af24d`, alive, cognitively braked at resident revision 384, with no active -lease or admitted work and zero defunct children. Do not disturb it before the -new source passes copied-state gates. - -Copied d7 replay did launch Research and Mind accepted its result, but that was -not the required public proof. The worker inspected only local frontier scope; -the accepted packet carried no `github://` source or `EyesSourceLookupReceipt`. -After acceptance, status still derived `launchResearch`. Operator-safe -diagnostics proved the request, launch, and packet job IDs matched: coverage -failed only because the mutable canonical coordinator thread had advanced away -from the request's creation thread. The same launch lacked a typed immutable -public target, so a root fixture file was correctly invisible. - -The repaired owner is the exact admitted RepoModel frontier. Research request -identity now derives from runtime identity, model hash, and exact frontier hash; -the thread is retained as creation provenance but cannot invalidate or fork the -request. A strict `github://owner/repository@40hex/path` subset of the -Modeling-owned frontier `evidence_refs` is copied into the v1 request and exact -worker launch context. The regression creates a request, changes coordinator -incarnation, replays the same request, binds an exact launch and packet, and -proves the frontier becomes covered. OpenAI fixture failures also exposed and -closed missing launch-carrier fields and missing source-worker/grant provenance -in tool-loop tests. Temporary debug prints were removed; formatting churn was -discarded rather than canonized. - -The source-tool authority wound is closed in source. Research, Modeling, and -Verification launches receive exact immutable read grants; Research alone -receives `publicSourceRead` and sees `epiphany_public.github_file`. Every -model-derived source-tool intent follows the inner model execution binding back -to the outer typed worker launch and exact Substrate Gate grant before intent -admission or adapter execution. The public reader accepts only one GitHub -owner/repository, exact 40-hex commit, repository path, bounded 64 KiB UTF-8 -body, no redirects, and no proxy. - -Generic result JSON is not Mind evidence. Runtime authenticates the complete -worker/model/tool/grant family, recomputes provider identity and content bytes, -and derives an `EyesSourceLookupReceipt`. Coordinator acceptance revalidates -that receipt inside the same full-snapshot CAS that commits the Eyes packet and -Mind update. The Research finding must cite the exact `sourceRef` in -`filesInspected` and `evidenceReceiptId` in `evidence`; invented `eyes-source-*` -citations fail closed. - -Focused hostile substitution preserves the runtime snapshot byte-identically. -The exact live reader fetched -`github://GameCult/Epiphany@43dc865e0f332b82de4b95292d5c600f8b901706/README.md` -as 8,162 bytes with SHA-256 -`0dfad0ab5211220f4126970be9d8dab66806d847efa21ba882dbffbb3eaf980c`. -Core tests pass 680/680 with one intentional helper ignored; tool runtime tests -pass 14/14 with one live network test ignored; OpenAI runtime tests pass 19/19. - -Exact `8fb61ac2` packaged as release -`sha256-1a00a080a793df9d9f8834ab6119678ee1855fc7cf9b2032a8868b4aa7d3b980` -with witness `sha256-e9a5401f29bedc4526b3fa2fec087ca20b379be38e509beffa557f043bd3b627`. -Copied c011 state then exposed a real routing fault: historical accepted -Research masked a newer actionable Eyes frontier. The local cut makes the -exact current frontier own an immutable `RepoFrontierResearchRequest`, carries -its exact projection in the Research launch, and consumes readiness only -through an accepted Eyes packet from that bound job. Exact `18966e55` packaged -cleanly as release `sha256-1e37ab44b403de1b7e2c59bce93caeadce18015204afbc783d310e382c1577f0` -with witness `sha256-e90cbf24b3f1f149e27665ebde2dc697428b76e169b1b52d47ebb5b1f5dd5941`. -Its copied-state replay exposed a second half of the same ownership fault: the -static Research role binding was already `Completed`, and policy treated that -historical terminal state as a reason not to launch against the newer request. -The local policy now suppresses current Eyes readiness only while Research is -`Pending` or `Running`; 24/24 Self-policy tests pass, including the exact -completed-binding regression. Next: commit, push, and package this final cut; -replay copied c011 state; accept one immutable public lookup -through Eyes into Mind; and prove missing `publicSourceRead` refuses without -consequence. Only then replace c011. Yggdrasil never builds. - -## Braked resident physiology no longer runs cognition ingress - 2026-08-11 - -Actual c006 remains exact `c9a2a979`, alive, cognitively braked, and untouched. -Its eight-hour endurance window held resident revision 34 with no active turn, -no restart, and no OOM, but read-only sampling exposed sustained resident CPU -spikes between roughly 9% and 24% at the shakedown's one-second idle cadence. - -The first owner cut, pushed as `7a8ef10d`, stops repeated runtime/session, -lifecycle, and worker-attempt retention after the first stable braked revision. -That reduced some spikes but left roughly 6-12% CPU. A readiness-publication -cadence hypothesis was packaged and falsified without improvement, then -reverted by `11a9e05c`; do not resurrect it as the explanation. - -Source inspection found the real hot owner inside `epiphany-swarm::cycle`: -the brake already blocked Bifrost import, but repository-domain binding plus -domain-pressure and coordinator-continuation ingestion still ran on every -braked pulse. Pushed `3f37503e` makes brake and shutdown block all new cycle -ingress while preserving state load and prepared/active child reconciliation. -Producer-owned typed evidence remains in its source store until release; the -brake does not delete it or synthesize a terminal state. - -Exact release -`sha256-aec4ed9382adb45e354f00a7af330c5b28e45d07900175f4bb8dfb4535cb6624` -and witness -`sha256-348ae07ed5cda07b350d13aa02620286f80cd7cbce9c9b7dc0e562c59fe8600b` -passed 24-binary inspection with zero warnings; warm Cargo took 3.13s. On the -same copied 23 MiB runtime store and one-second loop, six consecutive samples -were 0.29-0.33% CPU at about 47 MiB, down from 10-24% and 80-93 MiB. Resident -revision remained 66, runtime SHA-256 remained -`3cc2ef56...0bc6`, cognitive local-Verse SHA-256 remained -`d1efda5f...f395`, no grant appeared, and SIGTERM exited zero. Receipts are -under `.epiphany-run/linux-package-3f37503e`; stopped benchmark container logs -remain on `epiphany-braked-cadence-resident-3f37503e`. - -Released idle exposed the same cadence coupling outside the brake: at a -deliberately aggressive five-second poll, stable sleeping Self still paid a -large full-store retention scan on every pulse. Pushed `f04abd6b` makes -maintenance depend on startup, resident revision change, or a bounded -60-second maintenance deadline. Pressure ingress still runs at the configured -poll cadence, so wake latency and producer evidence ownership are unchanged. -Exact release -`sha256-544b95404d9445b2af0fdd67495bcff5f284ab2d2a29e16450e90d50f72a3f84` -and witness -`sha256-79639e35da79f7038111234fa33e21829e88eddcb77eb702f8f53f5369e9def3` -passed 24-binary inspection with zero warnings; warm Cargo took 4.33s. On the -same copied 23 MiB runtime, a released 30-second window at five-second cadence -used 91 process clock ticks, about 3.0% of one core, and slept near 0% between -scans. Revision stayed 66, no grant appeared, runtime SHA-256 remained -`3cc2ef56...0bc6`, the brake was restored, and SIGTERM exited zero. At the -production 15-second poll this scan cost scales to roughly 1% of one core. -An exact braked restart of the same package then held revision 66, the same -runtime/local-Verse hashes, no active/prepared turn, no grant, 0.36% sampled -CPU at one-second cadence, and a second clean SIGTERM exit zero. The cadence -cut therefore survives process re-entry without skipping startup maintenance -or resurrecting consumed work. - -The live Yggdrasil Persona boundary was also rechecked read-only. The exact -mouth service is active, enabled, restart-free, and listening on -`10.77.0.1:17876`; `/srv/bifrost/env/persona-delivery.env` remains absent or -empty, and no other root-managed bot-token file was found. This is still an -external credential decision, not corrupted runtime state. Do not fabricate or -borrow a bot identity. - -## Runtime-owned proposal Modeling first-result accepted - 2026-08-11 - -Actual c006 remains exact `c9a2a979`, alive and cognitively braked. All live -work below used fresh named-volume copies. The actual resident, Heartbeat, -runtime, and local-Verse stores were not mutated or stopped. - -The repeated duplicate-field failures were a symptom of the wrong output -owner. Generic proposal Modeling asked the model to author a complete -`RepoModelPatch`, including runtime identity, model base, Body observation -basis, request/proposal provenance, patch timestamps, deterministic frontier -identity, evidence binding, and nested patch anatomy. Pushed `9f82ee38` -removes that mouth. Proposal Modeling now returns one closed semantic -`proposalFrontierDraft`; runtime derives and authenticates every causal patch -field and publishes the exact patch through the existing admission path. -Duplicate JSON keys still fail closed. - -The exact `9f82ee38` package passed 24-binary inspection, but its fresh copied -gate exposed a provider-subset error before inference: `roleId` used `const` -without the `type` OpenAI requires. Pushed `e723058a` adds the type and a -recursive test that every constant in the dedicated schema declares one. -Focused core coverage passes. Persistent-cache packaging completed with Cargo -at 28.40s and produced exact 24-binary release -`sha256-6428f9194c261806a8859ccff9efeb9bb041a0103c5bbd8fac617aae265a651e` -and witness -`sha256-7ee2e14548bad526e946fbd79b555b7891d2eb6e2917856fefb1ebb7aeebd995` -with zero warnings. Receipts are under `.epiphany-run/linux-package-e723058a`. - -On a new copy, request -`repo-frontier-proposal-modeling-c6e584188580f373360a1b9d5113e2df67a22dd16c7cefcd97361067862b6d4b` -launched exactly one outer Modeling job, -`75a69738-b694-411c-bb6d-f823b39bd9e9`. It used five internal read-only model -tool follow-ups, produced one admitted runtime-owned frontier result on the -first attempt, and terminalized the exact proposal grant. Runtime ended with -zero open jobs and no actionable Hands or Eyes frontier. The copied brake was -restored; resident and Heartbeat both exited zero. Final state hashes and logs -are under `.epiphany-run/proposal-strict-live3-e723058a`. - -Do not flatten the remaining coordination wound. Heartbeat subsequently issued -two receipt-bound `reviewModelingResult` continuation grants for the same -completed proposal-bound result before the coordinator settled sleeping with -`modelingResultProposalBound=true` and -`modelingResultFailureReviewed=true`. This was not a second Modeling launch, -but it is not clean single-consumption review either. Next map the result-review -owner and require one proposal grant, one outer worker, at most one review -continuation, and exact settlement on a fresh copy. Yggdrasil never builds. - -The source owner is now mapped and cut. `resident_self_safe_continuation_action` -previously treated a receipt's direct `reviewModelingResult` action as runnable -without checking the detached result. That minted one premature grant; the -coordinator correctly returned `waitForModelingResult`, and only then did the -terminal-result path mint the real review. Direct Research, Modeling, and Soul -review continuations now share the same exact terminal-result predicate as the -corresponding wait conversion. That predicate also reads the heterogeneous -runtime store through `runtime_spine_cache`, not the thread-only reader. Thirty -resident tests pass, including a focused negative that pending review mints no -pressure and the same receipt becomes eligible exactly once after terminal -publication. Package and replay before accepting this coordination cut live. - -Exact pushed `9f597ca2`, release -`sha256-7bcd1d40fd68ca3ae4a0ca6722f81b708a18867aff7e83ff6e928b6bd17d2d23`, -witness -`sha256-66bd4be740907ac23a1b126f5c73454298db20498a92cc219735576629534ca8` -proved that pending-result fix live: no review grant existed while outer job -`e8d56041-c2f9-4c05-8629-8b7d1b206211` was pending. The terminal result then -received one legitimate review, but a second review was still issued. The -first review transaction had already rejected/superseded the proposal-bound -admission and derived `awaitFrontierProposal`; its coordinator receipt falsely -retained the pre-step `reviewModelingResult` action. The second continuation -performed only `requiredActionRefusal` with consequence `none`. The copy was -braked and both owners exited zero. Receipts are under -`.epiphany-run/proposal-review-live-9f597ca2`. - -Pushed `d4907ee8` fixes the remaining owner: after role acceptance, failure -supersession, or admission rejection, coordinator finalization refreshes the -receipt action from the post-transaction typed coordinator status. Nineteen -coordinator tests pass. Exact release -`sha256-81b4c14f0201f21adf8001f5dc5da81760697b03020fb4c2d6cb0e627efe16a0` -and witness -`sha256-5cf073e22a6d8fa93b5b7409c6a68f2f88d792dd9786c65e49000967ba61ea21` -passed 24-binary inspection with zero warnings; warm Cargo took 6.97s. - -Fresh copied request -`repo-frontier-proposal-modeling-507ad0a7dda5c8cc076b910f02d19c196b4cd5bb63e06ab25724aaac148897f8` -launched one outer Modeling job, `ebadfc7b-189c-4ac6-80c0-879ddb695cb5`. -The result received exactly one terminal review. That transaction rejected and -superseded the proposal-bound admission, and its receipt published the derived -`awaitFrontierProposal` action; no second review grant appeared. Runtime ended -with zero open jobs and Hands/Eyes false. The copy was cognitively braked and -resident plus Heartbeat exited zero. Final state hashes are resident -`163cbcbc...3905db`, heartbeat `909e023e...6a76d`, runtime -`3cc2ef56...0bc6`, and local Verse `d1efda5f...f395`. Container logs remain -attached to the stopped proof containers; receipts live under -`.epiphany-run/proposal-review-live-d4907ee8` and -`.epiphany-run/linux-package-d4907ee8`. Actual c006 was untouched. - -## Governed directory inventory accepted live - 2026-08-11 - -Actual c006 remains exact `c9a2a979`, alive and cognitively braked. All work -below used copied named volumes; the actual providers and stores were not -disturbed. - -The first copied turnover under exact `aa841873` exposed a sight gap rather -than laundering operator prose into evidence. Proposal Modeling received an -operator-supplied artifact count but correctly refused it because its governed -source organ could read files and Git objects but could not enumerate a -directory. Self nevertheless settled the typed Modeling request exactly once, -the copied brake was restored, and both owners exited zero. - -Pushed `31dcd351` adds a general workspace-confined `directory_inventory` -operation to `epiphany_source` and exposes it to Eyes, Modeling, and Soul. The -operation has explicit depth, entry, and sample ceilings; does not follow -symlinks; sorts paths deterministically; and marks totals admissible only when -`complete=true`. Focused native and OpenAI-runtime suites pass. Exact packaging -took 35.17s wall/Cargo 26.78s and produced 24 binaries with zero warnings, -release -`sha256-6cf496f71da98f07a5775c07a031108f643e0bd6081ac15bf338e109376fa6e8` -and witness -`sha256-5cca9d61b825bc2f54704c3d4f7b9049eec4d93de58e6d64f3f1d894b673966d`. -Receipts are under `.epiphany-run/linux-package-31dcd351`. - -The exact packaged replay asked Modeling to measure the copied actual -Heartbeat artifact family without operator counts. It invoked the new tool and -reported a complete inventory of 72 directories, 74 files, and 3,975,362 -regular-file bytes. It inspected bounded coordinator-running and routine -appraisal samples, but correctly refused the stronger claim that no post-brake -grant existed: artifact names are observation, not grant-death authority. The -model patch was rejected and its immutable selection consumed. Self then -completed two receipt-bound internal continuations and ended sleeping at -revision 54; runtime ended at 57 jobs/results, zero open jobs, and no Hands or -Eyes frontier. The copied brake was re-engaged and both owners exited zero. - -Next inspect existing typed Heartbeat and resident projections on copied state. -Identify the narrow owner that can prove a grant remains terminal and -unlaunchable after later grants and retention. Do not grant arbitrary -CultCache-reading authority to the source tool and do not infer from pulse -filenames. Route Eyes through the typed owner once that boundary is mapped. - -## Atomic Continuity repair and fast source-changing package accepted - 2026-08-11 - -Exact pushed `aa841873` removes a partial-commit seam from legacy coordinator -Continuity repair. The old loop could repair one valid session, encounter an -ambiguous later family, return an error, and leave the caller with a partially -mutated batch. Runtime Continuity now validates every observed candidate first -and publishes all completed sessions plus deterministic completion events in -one full-snapshot CAS. The hostile test includes a valid family before the -ambiguous family and proves the entire snapshot, including the valid Active -session, remains byte-identical. The full core library passes 670 tests with -one intentional ignore. - -This genuine `epiphany-core` delta closed the release-iteration falsification -gate. Using the persistent Starfire cache, exact source -`aa8418734e5634077c830ab9b786322925857a9e` completed in 37.27s wall time with -Cargo at 29.54s, down from the 5m02s source-changing baseline. Native inspection -accepted all 24 binaries with zero warnings as release -`sha256-dd4f05cb2e7f1b26156e7c9d5ed58f6d97ce5808d123b1bec343bfac59bf2ce7` -and witness -`sha256-793b29fcb7af4f8314a46f0fe0013cc8f5f382e7490a32c160385d29359adca5`. -An identical replay took 8.65s wall/Cargo 0.69s and reproduced both identifiers -exactly. Receipts are under `.epiphany-run/linux-package-aa841873` and -`.epiphany-run/linux-package-aa841873-warm`. - -Release construction is no longer the active machine fault. Keep actual c006 -alive and cognitively braked; resume copied-state autonomous cross-organ -turnover from its idle frontier. Recheck Yggdrasil's credential boundary before -attempting the one missing public Persona consequence. Yggdrasil never builds. - -## Genuine packaged Imagination option generation accepted - 2026-08-11 - -Actual c006 remains exact `c9a2a979`, alive and cognitively braked at resident -revision 34. All work below used fresh named-volume copies; no actual c006 -process or store was mutated or stopped. - -The first genuine copied run exposed two production ownership faults. Exact -`af2581b5` asked the model to echo causal candidate identity, and coordinator -finalization fenced the entire runtime snapshot. The model failed closed three -times with `candidate substituted causal identity`; an unrelated worker write -also caused `coordinator run finalization lost its full snapshot fence`. -Receipts and sealed copied state remain under -`.epiphany-run/imagination-af2581b5`. - -Pushed `b661ec4b` moved request, feedback, packet, classification, model, -contract, and publication-time identity into the authenticated runtime launch -context and changed coordinator finalization to CAS only its exact session. -The full core library passed 670 tests with one intentional ignore, the OpenAI -runtime passed 16 tests, coordinator passed 18, and swarm passed 7. Exact Linux -release -`sha256-61f1b2fb72f8869f79a0788bde09f7579d94572a2961ed55b8cac419b86d56ed` -with witness -`sha256-78567f04ffc182976debf0ad165f555a037324046a81a3daeae2673ba52e0b54` -passed 24-binary inspection. Its copied live run proved the remaining wound: -`evidence_refs` was still model-authored although candidate validation treated -those identifiers as exact quoted-evidence provenance. Three attempts again -failed closed; the copied runtime was braked and both direct-PID containers -exited zero. The rejected state and containers remain preserved under the -`b661ec4b` names. - -Pushed `acd91e6e` removes that final provenance mouth. The candidate schema no -longer accepts evidence identifiers; runtime copies the exact authenticated -`source_discussion_refs` from the request while the model owns only semantic -proposal content. The full core library again passed 670 tests with one ignore -and all 16 OpenAI runtime tests passed. Exact Linux release -`sha256-1c5a16efdfd02e453df0fc53c81cf1848ccaaca72e53c528f3385da9c8725085` -with witness -`sha256-b592d64ed0d0c3b7b1ef858ae96533a6e890e3805de94cf2aa6438b99eb39401` -passed 24-binary inspection with zero warnings. - -Fresh copied c006 then accepted the signed Bifrost `public_feedback` fixture, -issued exactly one Heartbeat consideration grant, and completed Imagination -job `12b670b7-e942-4390-98d7-54ab57908947` with result -`result-worker-12b670b7-e942-4390-98d7-54ab57908947`. Runtime admission -atomically published the deterministic candidate companion. Self moved -`awaiting-fulfillment -> completed -> sleeping` at revision 38 with no retry. -Runtime ended with 43 jobs, zero open, 43 results, `Hands=false`, and -`Eyes=false`. Mind, Body, and workspace-coverage SHA-256 values exactly matched -actual c006; copied workspace HEAD/status also remained identical. A braked -restart emitted only `braked` and `braked-after-ack-reconciliation`, issued no -grant, and both direct PID1 containers again exited zero on SIGTERM. No Persona -service or speech actuator was running; Heartbeat merely reserved the retained -copied mention before the brake was re-engaged. Full receipts are under -`.epiphany-run/imagination-acd91e6e` and -`.epiphany-run/linux-package-acd91e6e`. - -The Imagination live gate is accepted. The next release-iteration fault was a -split policy owner, not yet evidence that `epiphany-core` deserved surgery: -the root release profile enabled incremental compilation while release -construction unconditionally exported `CARGO_INCREMENTAL=0`. Commit `2f2cf6f8` -removes that override and leaves profile policy with the root manifest. The -one-time cache migration took 6m47s. An identical replay then completed in -8.76s wall time with Cargo at 0.77s and reproduced exact 24-binary release -`sha256-6cfafa4f3918a96a9ed7c080f6b52ed9e2ed750e7fad51f83f86354c1e90033a` -and witness -`sha256-f20677a44d0e29960f43d70091cacaab182e6939220a2173c3bf449392b427d9`. -Use the next coherent core-source shakedown cut to falsify source-changing -iteration speed against the 5m02s baseline before accepting the owner repair. -Do not split the core merely to improve a proxy. Yggdrasil never builds. - -## Runtime-owned Imagination candidate publication packaged - 2026-08-11 - -The Imagination option-generation audit found a production ownership hole: -runtime result admission authenticated the request, candidate, launch binding, -worker launch, model projection, and foreign-cargo exclusion, but persisted only -the generic worker result. Resident fulfillment required a separate typed -candidate envelope that tests wrote by hand. No production owner existed. - -Exact pushed `ff9dacf1` makes the existing runtime result-admission CAS own the -candidate companion alongside the worker result and terminal process claim. -Exact replay requires the companion to remain byte-equal. A pre-existing orphan -candidate refuses the worker result without writing it. The resident settlement -test no longer seeds candidate state manually. Focused atomic, orphan, and -receipt-free settlement tests pass; the full core library passes 670 tests with -one intentional cross-process helper ignored. - -Exact `ff9dacf1` packages 24 Linux binaries as release -`sha256-6d237cda95de91d999de7403d843507fac89f1f2c091b114957a33118063a03b` -with witness -`sha256-3b37136d34e4d4b886544102ec43a258510e246d762640a686b02b29fb13fafc`. -The release build took 5m11s with zero warnings and exact packaged inspection -passed. One rejected launch accidentally retained stale `ec54666c` source after -a bad expanded fetch SHA; it was stopped immediately and its logs/output remain -quarantined in the same receipt directory. The corrected source volume was -authenticated to the full `ff9dacf1` SHA before the accepted build. Receipts are -under `.epiphany-run/linux-package-ff9dacf1`. - -On copied c006 volumes, the exact release published and `epiphany-swarm once` -exited zero under the cognitive brake at resident revision 34 with no active -turn. Runtime, Mind, and Heartbeat stores were byte-identical; only resident -provider-readiness metadata advanced to the new release identity. The stopped -one-shot then projected `warming`, correctly refusing to impersonate a live -provider. Receipts are under `.epiphany-run/imagination-ff9dacf1`. - -Source and package ownership are accepted. A genuine model-produced copied -turn remains required: admit one fresh Persona-feedback consideration through -the existing typed ingress, run exact `ff9dacf1`, and prove result plus candidate -appear atomically while model/frontier/Hands/release/deployment authority stays -unchanged. Do not use a fixture candidate writer. Actual c006 remains exact -`c9a2a979`, alive and braked. Yggdrasil never builds. - -## Exact local-Verse reader isolation accepted - 2026-08-11 - -Exact pushed `ec54666c` packages 24 Linux binaries as release -`sha256-4d7347980f2fad658ebc6206b0435f29e1151cfbb75ec2806a8df2d5eb7f63bd` -with witness -`sha256-d5e6671cd70e1aeb3df21d1e69fb015b831e2c63c272d7ef3e3bf5f61aac15d1`. -The persistent Starfire cache completed the release build in 5m23s with no -warnings; exact packaged inspection found all 24 binaries. Packaging receipts -are under `.epiphany-run/linux-package-ec54666c`. - -The copied-state gate used two named volumes built from actual c006 local-Verse -state. Both received one valid Hands daemon-status fixture; the hostile copy -also received a registered Mind-contract envelope whose payload deliberately -cannot decode as that type. Exact packaged `swarm-status`, single-target poke, -restart-policy writing, and direct reconciliation all succeeded. Status, poke, -and policy projections were identical; reconciliation differed only in its -wall-clock field. Every original envelope remained byte-identical after all -three mutations, including the hostile row and payload. Receipts and the -verification script are under `.epiphany-run/narrow-verse-readers-ec54666c`. - -The nervous-system aggregate-reader audit is closed. Actual c006 remains exact -`c9a2a979`, alive and braked at resident revision 34: `ec54666c` changes only -operator query/supervisor paths, so replacing resident Heartbeat/Self bodies -would be churn without an invariant. Next map the incomplete Imagination -option-generation boundary from typed request through authenticated candidate, -with adoption and Hands authority remaining absent. Yggdrasil never builds. - -## Exact daemon-policy input cut - 2026-08-11 - -The refreshed Perfect Machine roadmap no longer names exact `16407f7e`, -resident revision 26, or multi-grant turnover as current work. Exact -`c9a2a979`, revision 34, and the accepted two-grant actual replay are current. - -The next nervous-system audit cut removes aggregate local-Verse context from -the single-daemon restart-policy writer. One exact typed daemon-status envelope -now owns the daemon and cluster identity copied into policy state. Persona, -Hands, receipts, telemetry, and unrelated daemon rows are not loaded. Aggregate -context remains with reconciliation and runbook paths that genuinely enumerate -topology, policies, statuses, and brake state. The exact loader test and the -negative source-boundary test pass. Continue classifying aggregate consumers; -do not package until a meaningful bounded batch earns a live body. - -Direct single-daemon reconciliation now uses the same narrow anatomy: one exact -daemon status, its exact policy, and the canonical brake. The brake helper no -longer accepts an aggregate context; focused tests prove protected -`daemon.lifecycle_poke` scope still refuses while the cognitive scheduler brake -does not claim service physiology. Scheduler tick and cluster runbook retain -aggregate reads because they genuinely enumerate several state families. The -remaining supervisor aggregate consumers are therefore classified. - -`epiphany-verse-query poke-daemon` is narrowed as well. It loads one exact -daemon status, the canonical brake, topology-family display metadata, and its -exact written intent by identity. The two aggregate context reads and their -now-dead context wrappers are deleted. Bulk poke, triage, and operator reports -retain aggregate reads because they enumerate daemon state. All 19 verse-query -tests pass with zero warnings. - -The complete batch verification is green: 669 library tests passed with one -intentional ignore, 29 daemon-supervisor tests passed, and all 19 verse-query -tests passed. Cargo emitted no warnings. Detached receipts are under -`.epiphany-run/narrow-verse-readers-161c6ec8`. - -## Actual receipt-bound turnover accepted - 2026-08-11 - -Exact pushed `c9a2a979` is now the active actual c006 body. Under a bounded -cognitive-brake release, the old `reviewModelingResult` receipt created grant -44. Mind rejected the unanchored patch and coordinator failure review wrote -exact supersession `role-failure-review-3e97a1f0-0511-4ab1-b84c-8132f2062042` -inside successful receipt -`coordinator-run-linux-eyes-tools-c005-1786407375735`. That receipt caused -distinct grant 48. The second coordinator rederived `awaitFrontierProposal`, -refused stale `reviewModelingResult` with `consequence:none`, and completed as -receipt `coordinator-run-linux-eyes-tools-c005-1786407379115`. - -Both grants own terminal `completed` state and terminal acknowledgements. -Resident state is revision 34 with no active lease and the second receipt as -its last exact receipt. The four pre-existing Hands/Persona/deployment-family -runtime envelopes are byte-identical to the before snapshot. The cognitive -brake is engaged, both exact providers remain alive, and authenticated -readiness is `active` with no reasons. Receipts are under -`.epiphany-run/c006-continuation-c9a2a979`. - -Actual receipt-bound turnover is accepted. `awaitFrontierProposal` is a typed -waiting state, not authority to fabricate backlog. Keep c006 braked while -inspecting the remaining organ matrix and choose the next bounded audit from -authoritative live state. Yggdrasil never builds. - -## Copied receipt-bound turnover accepted - 2026-08-11 - -Exact pushed `c9a2a979` packages 24 Linux binaries as release -`sha256-78b09d7c32867c71d593951f328a191b7261600a1d9e81d7fdcd35ce7414f218` -with witness -`sha256-ddf32da018f5a53eb87f3ed5b87ccfa57616203970d6fdab9641ee1ac8f71f24` -and zero warnings. Construction took 8m17s against the persistent Starfire -cache. Receipts are under `.epiphany-run/linux-package-c9a2a979`. - -A second stopped snapshot of actual c006 copied all three named volumes with -byte-identical manifests and restarted both exact actual owners after exit-zero -stops. Under copied brake, exact `c9a2a979` created one pressure from the old -`reviewModelingResult` receipt and no grant. Brake release issued grant 23. -Mind rejected the unanchored patch; coordinator failure review wrote exact -supersession `role-failure-review-5a612149-fc7f-4ea8-996a-a008547bfa2c` -inside successful receipt -`coordinator-run-linux-eyes-tools-c005-1786406310816`. That newer receipt -created distinct pressure/grant 27. The second coordinator rederived -`awaitFrontierProposal`, refused stale required action `reviewModelingResult` -with `consequence:none`, and completed as receipt -`coordinator-run-linux-eyes-tools-c005-1786406314165`. - -Both grants are terminal `completed`; resident state is revision 34 with no -active lease and the second receipt as its last exact receipt. All four -Hands/Persona/deployment-family runtime envelopes are byte-identical to the -untouched actual baseline. The copied cognitive brake is engaged, exact -readiness is active with no reasons, and both copied providers stopped with exit -zero. The contaminated first experiment is also braked, preserved, and stopped. -Receipts are under `.epiphany-run/continuation-c9a2a979` and -`.epiphany-run/continuation-4d6d269f`. - -Copied receipt-bound turnover is accepted. Publish exact `c9a2a979` into actual -c006 under its brake, replace the two provider bodies without changing stores, -authenticate readiness, run the same bounded two-grant path, and re-engage the -brake before continuing the next organ audit. Yggdrasil never builds. - -## Copied continuation exposed missing failure-review context - 2026-08-11 - -Exact `4d6d269f` packaged 24 Linux binaries as -`sha256-ff371697ce78a1daa3322c0cac988582d548747ae7fddbfb1d9f5626a37d3344` -with witness -`sha256-44c9d61787520a2f38fad1362230d283954a6019fd392600fe112115ca22c0fa` -and no warnings. A clean stopped snapshot of actual c006 was copied into three -named volumes with byte-identical manifests; the exact actual owners restarted -unchanged with exit-zero stop receipts. Under the copied brake, exact typed -inspection found one pending `coordinator-internal-continuation` pressure from -receipt `coordinator-run-linux-eyes-tools-c005-1786396551246`, required action -`reviewModelingResult`, zero continuation grants, revision 26, and no active -turn. - -After copied brake release, Heartbeat granted the pressure exactly once, but -Mind rejected the Modeling patch because `nodes[2]` had neither anchors nor a -source-hash anchor. The continuation launch omitted the coordinator's existing -`--supersede-failed-results` authority, so the rejection escaped as process -failure and Heartbeat issued twelve attempts before intervention. The copied -brake is engaged; attempt receipts and snapshots are under -`.epiphany-run/continuation-4d6d269f`. Actual c006 remained braked on exact -`16407f7e`. - -The source repair adds typed failed-result supersession only to receipt-bound -internal continuations. Mind still rejects the malformed aggregate; coordinator -failure review owns supersession and derives fresh work. The exact resident -argv test and all 18 coordinator tests pass. Commit and package this repair, -then replay from a fresh pre-fault clone. Require one rejection/supersession, -a newer causal receipt and grant, no process-failure retry loop, and zero -Hands/Persona/deployment consequence. - -## Internal cognition continuation implemented; live proof pending - 2026-08-11 - -The post-endurance audit found actual c006 coherently asleep but unable to turn -over its next frontier. Exact packaged status says `reviewModelingResult` for -proposal Modeling job `5ff2704b-64eb-42f1-9ca4-ca7144e33ae4`; runtime has no -actionable Hands or Eyes frontier, Imagination eligibility is empty, planning -is terminal, and resident pressure is empty. Releasing the brake would do -nothing. - -The source cut makes the last exact resident-bound coordinator receipt own one -possible internal-cognition continuation. Only safe Research, Modeling, -Verification, Imagination-planning, and Mind-planning actions can become an -idempotent pressure. Its coordinator launch is objective-free, execute-mode, -auto-review, exactly one step, and fenced by `--required-action`. Live routing -drift records a no-consequence refusal before the action match; it does not fail -and requeue the stale pressure. Hands, Persona, deployment, external -consequence, waits without terminal results, and failure review cannot create a -continuation. Thirty resident tests and all 18 coordinator tests pass. - -Next: commit and package this exact source with the persistent Starfire cache, -then run copied c006 under its brake. Require one pressure from the stranded -receipt, exact Modeling review/admission, a genuinely newer causal receipt and -grant, no Hands/Persona authority, bounded resource behavior, and clean -re-engagement. Actual c006 remains exact `16407f7e`, braked and unchanged. - -## Actual c006 braked endurance accepted - 2026-08-10 - -Exact `16407f7e` remained alive in separate Heartbeat and resident Self -containers for a detached 900-pulse target window. The monitor began at -iteration 572 and completed at 1496. Thirty samples observed iterations -573-1496, a 923-pulse delta. Every sample was -`braked-after-ack-reconciliation` with the canonical brake, no grant, resident -revision 26, no active turn, and no authority deviation. `/state` remained -exactly 18,161,109 bytes and `/workspace` exactly 114,209,526 bytes. Heartbeat -RSS stayed within 28.63-28.88 MiB; resident Self stayed within 54.11-55.50 MiB. -Both owners remained live. An exact packaged final status authenticated the -release and witness, reported the cognitive runtime -`epiphany-starfire-linux-eyes-tools`, observed the brake engaged, and projected -readiness `active` with no reasons. Receipts are under -`.epiphany-run/c006-endurance-16407f7e`. - -The stale July audit roadmap was replaced with the current organ authority -matrix. Commit `5fbb8690` also narrows managed-task lifecycle, service-runbook, -and repo-work service-audit brake decisions to the canonical typed brake loader; -cluster and prompt paths retain full Verse context only where their outputs -actually aggregate it. Twenty-six daemon-supervisor tests pass. - -Next: map and run bounded autonomous frontier turnover across Self, Eyes, -Modeling, Imagination, and Mind on copied exact state before opening an explicit -actual-c006 brake window. Require several causal grants, no Hands or Persona -consequence, preserved typed chains, and a final re-engaged-brake readiness -proof. Yggdrasil never builds. - -## Actual c006 woke and completed retained Modeling once — 2026-08-10 - -Exact `0ef0c0b8` was published into actual c006 under its cognitive brake. Exact -Self authenticated it at revision 23 with no active lease. Heartbeat and Self -then started as distinct long-lived container owners. An explicit typed brake -release created no grant; it allowed the already-retained, unconsumed -proposal-Modeling grant to launch exactly once. Coordinator thread -`linux-eyes-tools-c005` opened runtime job -`5ff2704b-64eb-42f1-9ca4-ca7144e33ae4`; the detached Modeling worker published -valid typed fulfillment. Self advanced 23 -> 25 -> 26 through launched, -awaiting-fulfillment, completed, then sleeping. Heartbeat returned to bounded -void routines without a replacement grant. No Hands, Persona, deployment, or -other external consequence occurred. Exact before/after manifests, brake -transitions, provider logs, and status projections are under -`.epiphany-run/c006-wake-0ef0c0b8`. - -The live run exposed one readiness ownership fault. Both providers were alive, -but status reported warming because its early snapshot time raced continuously -refreshed rows and because one container cannot observe the other's PID -incarnation. The accepted source cut makes the shared-store role singleton own -cross-container liveness and keeps the exact fresh provider row as -release/witness/source/executable identity. PID sight is diagnostic. Evaluation -time is sampled only after loading each exact row, so slow witness authentication -cannot race a provider refresh. Rows more than one second beyond that observation -still refuse. Fifteen focused tests and all 666 non-ignored core library tests -pass. - -Exact `16407f7e` packages this cut as 24-binary release -`sha256-66cf1c2f4d88e7885a36870277cf4b143204de9c9b0dad0ed8f809983b3c55af` -with witness -`sha256-5f41248bb11c01f19125f16bf39f3dfcc2a802de211f3eae7e2caf292d59e4b3`. -On copied c006 stores, two distinct PID namespaces projected active; stopping -only Heartbeat immediately projected warming with exact `role-singleton` -failure while its row remained fresh; restart restored active; both owners then -accepted SIGTERM and exited zero. Actual c006 now runs the same exact body under -its engaged cognitive brake and projects active with no reasons. Receipts are -under `.epiphany-run/readiness-16407f7e` and -`.epiphany-run/c006-readiness-16407f7e`. Run the 900-pulse braked plateau next. -Yggdrasil never builds. - - -## Direct proposal Modeling and archived fulfillment accepted — 2026-08-10 - -The exact `53678374` Linux body now carries a direct proposal Modeling proof in -`.epiphany-run/worker-retention-53678374/runtime-proposal3.cc`. Production APIs -own the immutable user proposal and selected request, generation-one Body -carrier, exact Modeling launch binding and document hash, terminal worker -result, accepted Evolution patch, and Mind receipt -`repo-model-admission-review-proposal-direct-3`. The admitted patch contributes -exactly one proposal-citing active frontier routed to Eyes; it grants no Hands -authority. - -With zero coordinator receipts, exact runtime fulfillment closed the original -resident grant `recovered-fulfilled`. Packaged `epiphany-swarm once` then exited -zero `braked` and retired the consumed pressure/grant/ack lifecycle beside its -readiness row. Explicit runtime archival replaced eight worker envelopes with -one proposal-Modeling tombstone. Fulfillment before and after archival resolves -to request -`repo-frontier-proposal-modeling-a9807416c62a69eb7f8f4524fa75fe3fc1cb119b43813f62d3299300074c7e56`, -job `proposal-direct-3`, and result `result-proposal-direct-3`; launch, job, and -claim are absent afterward. A later Heartbeat issuance selected only the new -admitted-model-direction pressure created by Mind admission. No proposal retry -or active resident turn exists. - -Rejected fixture shapes remain preserved: missing model schema, revision-one -model without an exact self-hash, and a recovery timestamp earlier than its -coordinator start. Each failed closed. Actual c006 stayed untouched and remains -braked/stopped. Direct proposal fulfillment is accepted. Deployed -supervisor/projector stdout-stderr ownership was already accepted under -`gamecult-ops` `059821f`: both projector policies inherit `/dev/stdout` and -`/dev/stderr`, while systemd-journald is the sole deployed retention owner. -Exact packaged interruption falsified the Starfire `F:` bind as a mutable -authority substrate: a lockless reader observed an empty published snapshot -while an exact packaged writer was being killed. A Docker named volume instead -survived sixty randomized writer kills and five million concurrent lockless -reads with only parseable, monotonically nondecreasing snapshots. Exact -`a4756857` then repeated the stronger test: forty real writer incarnations died -with SIGKILL 137 while a lockless verifier completed ten million reads spanning -102-201 envelopes without empty, partial, decode, or rollback. CultCache removes -only its own UUID-shaped abandoned staging files on the next exclusive write. -A copied c006 restart is clean and actual c006 remains untouched. Exact payload -inspection corrected an initial false alarm: the retained grant is unconsumed, -nonterminal, and exactly matches Heartbeat's running schedule/action. The brake -is coherently holding pending authority; there is no orphan repair to perform. -The release source guard now pre-cleans cached submodules, updates only changed -pins without `--force`, then re-cleans and verifies the exact tree. Its twenty -focused tests pass. Exact pushed `0ef0c0b8` packages 24 Linux binaries as -`sha256-032af7baa251caf32c1843eeace8990001557fe916988d8d1e2f0a27093a2b36` -with witness -`sha256-c0b8dbac33f821e9adc15218ea22a9133e0b9ea78f1981916b403fcad79f3d3b` -and zero warnings. The source-changing Cargo pass fell from 11m04s to 7m19s, -compiling six first-party crates and no vendored or external crate. An exact -warm replay finished in 5.8s wall / 0.77s Cargo with identical release and -witness. Publish this body to actual c006 under the brake, authenticate it, then -wake Heartbeat and resident Self and prove the retained grant is consumed at -most once through its typed lifecycle. Yggdrasil never builds. - -## Exact packaged outer-worker retention accepted — 2026-08-10 - -Exact pushed source `53678374adbab1552605817f41d9978ba587c52e` -packages from the stable Docker source clone `/source/repo-live` as the 24-binary -release -`sha256-5d50fa7dab6bbfae78982d6dd8e8a21f2c3642bb6678686660c59fb42aa97d05` -with witness -`sha256-1814d2b7ee0bd93ab93a2878beb6ab7916fa7e1a476b8bde6dc7e06cd79bda73`. -The one-time stable-path cache migration took 15m50s; inspection found exact -source and zero warnings. Package receipts are under -`.epiphany-run/linux-package-53678374`. - -Copied Linux state under `.epiphany-run/worker-retention-53678374` is bound to -an authenticated generation-one Body at exact source `53678374`. Exact packaged -`epiphany-swarm once`, under the copied cognitive brake and retention window -one, exited zero twice. The failed pass archived only `failed-old-clean2`, -replacing its exact seven-envelope launch/job/claim/binding/event family with a -typed tombstone; `failed-new-clean2` remained terminal and live. The fulfilled -pass archived only `fulfilled-a5`; `fulfilled-z5` remained a Completed job with -a terminal-result claim. Runtime fulfillment still resolves the archived and -live admitted-model-direction requests to their exact job/result IDs. The -tombstone preserves evidence but cannot become a launchable attempt. - -Several fixture mistakes failed closed and are useful receipts: a foreign -Persona document source, a missing Body route, a Modeling carrier without Body -basis, a direction projection with the wrong model hash, and a worker job mixed -into the coordinator's jobless Continuity session. None weakened production -gates. Actual c006 was never mounted writable and remains braked/stopped. - -Next construct one direct Linux-native packaged proposal Modeling lifecycle. -Require exact proposal/request/payload, Body-bearing launch and hash, successful -Modeling result, admitted Evolution patch with one safe routeable frontier, -zero-receipt recovered-fulfilled settlement, resident and worker retention, -archived fulfillment replay, and no retry. Then return to deployed log ownership -and randomized bind-store interruption proof. Yggdrasil never builds. - -## Worker terminal-failure ownership exposed live and repaired in source — 2026-08-10 - -Exact packaged `75b84180` copied-state runs now prove both claimed and active -SIGKILL orphans become `terminal-death` only after Linux exact-process -observation. Replaying the claimed recovery returned success without changing -the runtime-store SHA-256. A persisted active resident lease then settled -through production `settle_resident_self_exited_coordinator`: the lease cleared, -the exact grant became `process-failed`, one cancellation ack appeared, and the -pressure returned to pending once. Heartbeat issued attempt two for that same -pressure. A distinct packaged job/process became active while the prior claim -remained terminal-death, proving no dual live attempt. Receipts are under -`.epiphany-run/worker-continuity-75b84180/typed-claimed-sigkill/` and -`typed-active-sigkill-3/`. - -The retry worker then exited zero after a typed model-transport failure, with a -generic failed runtime result but an incorrectly surviving `active` process -claim. This is a real Continuity fault: generic completion and process -terminality had split writers. Current source makes `complete_runtime_job` one -snapshot-fenced transaction for job, result, completion event, and exact active -claim. A generic worker completion becomes `terminal-failure`; an admitted -reorient result remains `terminal-result`. Proposal Modeling, Imagination, and -admitted-model-direction retry predicates accept terminal-failure as exact -supersession authority. No cleanup loop was added. - -Core passes 661 tests with one intentional ignore. The OpenAI runtime passes 15 -library tests, 10 model-runtime tests, and 10 openai-runtime tests. The cut is -not yet committed or packaged. Next review/commit/push it, package exact source -once on Starfire, then replay the packaged activated transport failure and -require atomic terminal-failure plus canonical resident settlement/retry and -retention non-resurrection. Valid-result-before-coordinator-receipt remains -open. Actual c006 remains braked and stopped. Yggdrasil never builds. - -## Packaged worker start gate accepted — recovery/retry still open — 2026-08-10 - -Exact pushed source `75b841808bb5f693acfe4513befd430fbaf65b75` -passed core 660/1 ignored, swarm 9/9, coordinator 17/17, and OpenAI runtime -10/10. It packaged in 6m32s without warnings as the 24-binary release -`sha256-3959bcb3705a59a3a881e248b71e245faa5cf16f6dcc93ce49968957fb2a0301` -with witness -`sha256-6e34eb0aa60e4427ca45f42d02705ff5b87aef4dfb18644c03c7dcb1895bc39d`. -Independent inspection authenticated exact source, runtime, witness, and all -24 binaries. Package receipts are under -`.epiphany-run/linux-package-75b84180/`. Three earlier containers in that -directory are preserved pre-build source-preflight refusals caused by an -uninitialized submodule clone and a staging-only URL override; only container -`epiphany-linux-package-75b84180-4` entered Cargo and completed the release. - -The exact packaged `epiphany-model-runtime` then ran against quarantined copied -CultCache fixtures under `.epiphany-run/worker-continuity-75b84180/`: - -- no activation: the claim remained `claimed`, no model-adapter job appeared, - and the ten-second gate replaced it once with `terminal-unactivated` plus one - outer-job failure; -- SIGKILL while `claimed`: exit 137/no OOM, exact claim durable, outer job still - queued, no result or model-adapter job; -- explicit capability activation then immediate SIGKILL: the activation API - returned `active`, exit 137/no OOM, exact active claim durable, outer job - queued, and no result or model-adapter job. - -This accepts the deployed worker start gate and both orphan shapes. It does not -yet accept resident death recovery or retry. Next extend the quarantined fixture -with exact typed grant/lease authority and run packaged Self/Runtime Continuity -over both orphan stores. Require `terminal-death` only after exact Linux process -observation, canonical `process-failed` settlement and one requeue, a distinct -retry incarnation for the same request, no dual worker, exact replay, and -retention non-resurrection. Then prove valid result before coordinator receipt -closes once without retry. Actual c006 stays braked. Yggdrasil never builds. - -## Orphan-worker Continuity source complete — 2026-08-10 - -The runtime now persists one `EpiphanyRuntimeWorkerProcessClaim` per immutable -worker job. `run-worker` claims its own PID, creation token, executable, and -activation-capability digest before watchdog, provider, model, or tool work. It -waits for the coordinator to observe that exact claim and present the matching -capability. Failure to activate terminalizes the claim without cognitive work. -An authenticated worker result and `terminal-result` claim replacement share -one snapshot-fenced transaction. - -Resident Continuity resolves the request's exact worker launch and claim. Only -native `Missing`, `Replaced`, or exact exit observation may replace a claimed or -active process with `terminal-death`; alive waits, inaccessible/indeterminate -fails closed, and a result race refuses. Self then uses its existing -`process-failed` terminal vocabulary to clear the exact lease, terminalize the -grant, and requeue pressure once. `roleFailureReview`, coordinator receipt -absence, elapsed time, and legacy claimless launches grant no retry authority. - -Proposal Modeling, Imagination consideration, and admitted model direction now -share this terminality predicate. Imagination retries receive distinct binding -IDs; every lane receives a distinct backend job. A dead process also demotes -the stale active runtime-link projection so it cannot veto the new launch. -Attempt history and terminal claims remain immutable. Focused user-story tests -prove refusal before terminality and successful retry afterward for all three -lanes, including canonical resident settlement. Full gates pass: core 660 -passed/1 ignored, swarm 9/9, coordinator 17/17, OpenAI runtime 10/10. - -This cut is not yet committed, packaged, or accepted on Linux. Next commit and -push it, package exactly once with the persistent Starfire cache, authenticate -the 24-binary release and witness, and run the copied-state kill matrix at -pre-claim, claimed/unactivated, activated/pre-result, and valid-result before -coordinator receipt. Prove same typed request with distinct incarnation, -no dual live worker, no pre-activation model/tool work, exact settlement, and -retention non-resurrection. Actual c006 remains braked. Yggdrasil never builds. - -## Heartbeat graceful SIGTERM accepted on Linux — 2026-08-10 - -Exact pushed source `bfb92cbb96e8ac085222844d3aa51681d15e18d1` -packaged in 6m12s without warnings as 24-binary release -`sha256-6f1f4eff32fab17cf3ffa2c7be7b911138c18cc09fad7d3271e1ca02559fe54f` -with witness -`sha256-fda39e34d6f30a606f19736f96769613262997a35db63560165049a7db2e12da`. -Independent inspection authenticated exact source, runtime, witness, destination, -and all 24 sibling binaries. Package receipts are under -`.epiphany-run/linux-package-bfb92cbb/`. - -On copied c006 state, packaged Heartbeat authenticated the published release and -mounted cognitive runtime, observed the engaged cognitive brake, and emitted no -grant. SIGTERM arrived during its configured 30-second interval. The process -stopped in 0.358 seconds with exit zero and no OOM; its final -`epiphany.heartbeat.serve_receipt.v0` states `stopped-cleanly` and -`shutdownRequested:true`. Resident, runtime, and cognitive local-Verse SHA-256 -values were byte-identical before and after. Receipts are under -`.epiphany-run/heartbeat-sigterm-bfb92cbb/`. - -Heartbeat graceful termination is accepted. Actual c006 remains braked and its -old resident/Heartbeat containers remain stopped. Next resume copied -receipt-free coordinator death: prove the pre-open boundary and then resolve the -post-open split between already-authenticated typed fulfillment and an orphaned -immutable worker launch. Do not manufacture retry authority or delete launch -history. Yggdrasil never builds. - -## Heartbeat graceful SIGTERM source complete — 2026-08-10 - -Heartbeat `serve` now owns SIGINT/SIGTERM with one process-local atomic signal -owner. Shutdown is observed before admitting the next pulse, all interval waits -are interruptible, and signal or bounded completion converge on the existing -typed serve receipt. The receipt now states `shutdownRequested`; an in-flight -atomic pulse is allowed to finish before closure. No persisted shutdown command, -retry writer, or Docker-timeout compensator was added. - -Six focused Heartbeat binary tests pass, including signal/boundary stopping and -immediate interruption of the interval wait. The Heartbeat binary checks without -warnings and `git diff --check` passes. This cut is not yet committed, packaged, -or accepted on Linux. Next: commit/push, package exactly once on Starfire, and -run packaged serve on copied c006 state under its cognitive brake. Send SIGTERM -during an interval and require exit zero, a final typed receipt with -`shutdownRequested=true`, no new grant, and byte-identical resident/runtime -authority. Do not release actual c006. Yggdrasil never builds. - -## Typed-attempt non-resurrection accepted and actual c006 settled — 2026-08-10 - -Exact pushed source `c693aaeadbb17204724c9986f16952e2f93e8fc9` packages -without warnings as 24-binary release -`sha256-fd46323a0164d33dd5f71f557aa9406b4bec699f453a74aee428c99b2c252e71` -with witness -`sha256-8ad95c0a08fe1fe7398f62a94ca10c1da56170b36e552c1700968efc2a7ac16d`. -The cut validates structural coordinator-receipt binding before classifying -status and forbids an immutable typed attempt from returning its pressure to -Heartbeat. - -On an exact copy of the sealed c006 failure stores, packaged Self settled the -attempt-two lease with exit zero at resident revision 22. The exact grant is -terminal `unfulfilled`, its pressure remains `consumed`, and bounded Heartbeat -replay under the cognitive brake issued no third grant. Resident serve projected -braked state and handled SIGTERM with exit zero. Receipts are under -`.epiphany-run/replay-c006-c693aaea/`. - -Standing corrupted-state intervention authority was then exercised on actual -c006. The authenticated c693 release replaced only the release publication, -and packaged Self settled the same exact lease with exit zero, no OOM, and no -active turn. Bounded Heartbeat pulses 138 and 139 both reported -`braked-after-ack-reconciliation` with no grant. Pre-intervention stores and -container evidence remain under -`.epiphany-run/interventions/c006-unsuperseded-relaunch-20260810T1044Z/`; -post-settlement logs are under -`.epiphany-run/interventions/c006-c693aaea-settlement/`. - -The cognitive brake remains engaged. Old c006 resident and Heartbeat containers -remain stopped; do not release the brake. The next source cut is Heartbeat -graceful SIGTERM ownership: the old continuous Heartbeat body required Docker's -kill timeout and exited 137. Map that nervous-system lifecycle, make termination -produce an exact clean receipt, package once, and replay on copied state before -resuming receipt-free death/orphan-worker Continuity. Yggdrasil never builds. - -## c006 live scheduling exposed typed retry resurrection — 2026-08-10 - -Exact pushed source `8d92c8266b07a98b5c6b2e8d6bdbded5661e8cbb` packaged -without warnings as 24-binary release -`sha256-e0f5b6084ea779dd0a7e22536b2cf371c0579b8ab06e52f728ddc8912caf2dab` -with witness -`sha256-8a8833b7a501a774173debe6b93658f1885691b3f35a1c7534e907d26d8860ea`. -The integrated copied-state negative proved that resident Heartbeat observes -the mounted cognitive brake namespace even when release identity differs. - -On actual c006, Heartbeat consumed the historical terminal acknowledgement -without reissuing either old grant. The first admitted-model-direction grant -completed exactly once. Proposal Modeling then completed one valid request and -advanced to another. That later worker persisted an immutable launch and a -terminal result which failed runtime fulfillment validation. Resident Self -cancelled and requeued the same typed request; Heartbeat issued attempt two; -the coordinator correctly refused it because attempt one's launch remained -unsuperseded. The resulting fully bound `failed` coordinator receipt then -crashed resident settlement because the receipt lookup incorrectly used the -success-only validator before status classification. - -The cognitive brake is engaged on -`epiphany-starfire-linux-eyes-tools`. Both c006 processes are stopped. Heartbeat -still lacks graceful SIGTERM and stopped with exit 137 after observing the -brake. Exact copied stores, container inspection, and logs are preserved under -`.epiphany-run/interventions/c006-unsuperseded-relaunch-20260810T1044Z/`. -Do not release the brake or restart c006 from `8d92c826`. - -Current source moves both decisions to their owners. Receipt binding is checked -independently of terminal success, so a fully bound failed receipt reaches -settlement. Once a typed attempt exists, pending work retains the active lease -and hostile terminal output closes the exact grant as unfulfilled without -returning its pressure to Heartbeat. Generic cancellation may requeue only -before a typed attempt exists. The live-shaped regression proves a bound failed -receipt plus hostile terminal claimant cannot mint attempt three. The full core -suite passes 654 tests with one intentional ignore; nine swarm binary tests and -warning-free lib/swarm checks pass. Commit/package this cut once, then replay -against a copy of the sealed c006 failure state. Require exact settlement, -consumed pressure, no new grant, parseable stores, and clean resident restart -under the cognitive brake before touching actual c006. - -## c006 recovery exposed Heartbeat identity and legacy-session residue — 2026-08-10 - -Exact `9bf985fc4ab5a7f75de26493ed6e122524c71775` packaged in 6m46s as -24-binary release `sha256-eedde4e6257dbf9ad700ad6a8793599504ae4b7bbf86147ced1275fa8596e9d3` -with witness `sha256-828949cd0a4ad865c5a43e68079f9b8db36d63b992a72d6f191b6c18bd241b73`. -Inspection passed and no warnings were emitted. - -c006 first refused before cognition because the copied runtime retained one -legacy active session ID reused across 24 unbound starts and 22 receipts. A -proposed latest-timestamp repair was rejected: timestamps cannot bind a receipt -to an incarnation. The exact pre-intervention runtime -`sha256-8aace759c246bd45b86c32cf0f15ce518eab12e2b2aa91f57a8dc764f5d08c84` -is preserved under -`.epiphany-run/interventions/c006-ambiguous-legacy-receipts/`. The stopped-volume -intervention removed the entire unbound session/start/receipt family under a -full-snapshot fence; exact packaged runtime parsing passed and no remaining -envelope references the legacy session. External typed receipt -`quarantine-receipt.json` records the cut. No guessed completion was created. - -c006 then started sleeping and stopped by SIGTERM with exit 0, but no Heartbeat -pulse was allowed: Heartbeat serve still selected the release runtime for its -brake. Current source requires `--resident-runtime-store`, resolves mounted -cognition for scheduling brake lookup, and retains release identity solely for -provider/binary authentication. Four Heartbeat binary tests pass, including a -deliberate deployment/cognitive identity split. Commit and package this final -identity cut before pulsing c006. - -## Cognitive brake identity cut — 2026-08-10 - -Exact crash-atomic source `0e8cd91af1dae0b48c59a6c0985075279ee58a6b` -packaged without warnings as 24-binary release -`sha256-ff906f3850e3ceaf743ce330116d545d57efb3340a69da186d834392fa8f1dcf` -with witness -`sha256-ea0997317b82fae9117d96ef2cfc7289d0aa552405275b89160c4e30cb4fef2b`. -Independent packaged inspection passed. Construction took seven minutes after -the CultCache source hash invalidated the release graph. The first bootstrap -attempt refused before compilation because its local submodule URLs still -named the bundle mount; the corrected canonical-URL attempt is the accepted -package. Receipts are under `.epiphany-run/linux-package-0e8cd91a/`. - -Do not start c006 from that release. Recovery preflight found that prepared -coordinator argv already uses the mounted cognitive runtime identity, but -resident `NativePorts` still read the local-Verse brake under release/provider -identity. Current source resolves the immutable mounted runtime identity once -and uses it for every resident brake observation, so resident and child share -one kill-switch namespace. Readiness now projects mounted cognition as -`runtimeId`, authenticated binary provenance as `releaseRuntimeId`, and reads -the same cognitive brake. Release identity remains binary/provider provenance; -Persona feedback target remains a crossing contract. Thirteen focused readiness -tests and all nine swarm-binary tests pass, including deliberate -`deployment-runtime` versus `cognitive-runtime` cases. Commit/package this -narrow correction before c006. - -Recovery state is staged but inert in named volume -`epiphany-resident-c006-state`. Its resident snapshot comes from -`coordinator-session-live-5a479522`: heartbeat, top runtime, Eyes runtime, and -Eyes local-Verse hashes prove that copied run descended from c005's surviving -state. The snapshot records sleeping revision 6, both original grants terminal, -and one typed admitted-model-direction pressure pending. Derived provider -readiness will be republished. The zero file was not imported. - -## Starfire reboot exposed non-atomic CultCache publication — 2026-08-10 - -Live c005 and the copied e97 Continuity harness independently lost only -`resident-self.cc` during the same host restart. The files were replaced 0.563 -seconds apart at `09:15:18Z`/`09:15:19Z`, each became a nonempty file consisting -entirely of zero bytes, Windows booted at `09:16:52.500Z`, and Docker later -reported c005 exited 255. Every sibling c005 `.cc` store remained nonzero. The -exact corrupt c005 bytes, hashes, container state, and host-event correlation -are preserved under -`.epiphany-run/interventions/c005-zero-store-20260810T091926Z/`. Do not restart -c005 and do not describe this as a clean shutdown. - -The source owner was CultCache's single-file publisher: it deleted the committed -destination before renaming a staged snapshot. Upstream CultCache `e8a9f2d` -now flushes a unique staging file, atomically replaces the sibling destination, -and performs the Unix parent-directory durability barrier; Windows uses -write-through replacement. The individual replacement and directory-sync calls -work on Linux overlayfs and the writable Starfire `F:` bind, but the full -packaged interruption test rejected the bind. A concurrent lockless reader -observed an empty published snapshot while the exact packaged runtime writer was -killed; the store later decoded with 90 events. Two abandoned UUID staging files -remained. `F:` therefore cannot own mutable Epiphany state. - -The same exact release on Docker named volume -`epiphany-cultcache-interruption-53678374` survived sixty independently named -writer containers killed at randomized 1-150 ms boundaries. Exact packaged -status decoded after every kill and the event count never rolled back. A -concurrent lockless reader completed 5,000,000 reads, observing 136-164 -envelopes with no empty, partial, undecodable, or regressing snapshot. The final -store contained 163 events, retained mode 0644 and uid/gid 0, and hashed -`39026d9d5d432ab24ca3f2a737ed2498728006e89b794d18a4f9cf371f5fb9b7`. -Three abandoned UUID staging files remained after killed writers. - -CultCache `0ba8745` assigns bounded staging cleanup to the next exclusive writer. It -deletes only regular siblings named exactly `..tmp`; unknown -suffixes, other destinations, directories, and symlinks are not cleanup -authority. Forty-one library tests and 664 core library tests pass. A stale -supervisor source-shape test was corrected to verify exact call arguments -without claiming indentation authority; all 25 supervisor tests pass. The -exact package is source `a4756857`, release -`sha256-b2e2793ea7205d497e8f1b85b3a23488f844213dd913b08fd9082ede26a76e07`, -and witness -`sha256-4bdb22ff7a4363176aaef325222c55c08b75ee464c98a57be5a983bc43dd9917`. -Forty looping packaged writer containers ended with SIGKILL 137; exact status -decoded monotonically after each. A concurrent lockless verifier completed -10,000,000 reads spanning 102-201 envelopes with no empty, partial, undecodable, -or regressing state. The final clean write produced 200 typed events, preserved -0644 root:root, hashed -`5e3518da84cabac4afa1f22187f8e90a9a02ea820b5a13eab32627c1e375c875`, -and preserved the hostile unknown, foreign-store, directory, and symlink shapes. -Named-volume mutable publication and staging cleanup are accepted. The zero file -is evidence, not a migration input. - -Copied c006 state, workspace, and Codex home matched 26-file, 4,301-file, and -one-file SHA-256 manifests before mutation. The new release published only into -the copy; exact swarm `once` remained braked with no active turn, and bounded -`serve` accepted SIGTERM with exit zero and final braked state. Original c006 -state and workspace manifests remained -`3bef83075f18f9ebaff30c432fd9429b6b3dd7bdf00ea10a0913ee06a7a04d2f` and -`eb3de02d206b61b741816907e4653d155b9bec1a2dd7089d44eeec393d1e1b70`. - -Heartbeat and resident state are coherent under the brake. Heartbeat retains a -running `epiphany-starfire-linux-c006-bounded` coordinator turn; the resident -store retains its exact proposal grant for request `ef710ca4...`. Forensic typed -payload inspection proves `consumed_at_millis = None`, terminal fields absent, -and exact schedule/action equality. No prepared/active lease or child claim -should exist before Self consumes the grant. The generic heartbeat status makes -the coordinator look frozen because that is precisely what pending braked -authority means. Do not repair or terminalize it. Actual c006 remains untouched. - -## Cross-container resident ownership accepted — 2026-08-09 - -Exact `c930f505` release -`sha256-cd684079eec277bbb434f147c4f6c679553780230822f9d30f0810ec0988100a` -with witness `sha256-c7642818f076f7109585a6e7021371815607fb7ecb141cb2b7c008335fbecec4` -passed independent 24-binary inspection. In copied state, a resident owner reached -sleeping and created `resident-self.cc.resident-self.process.lock`. A second -container was refused with exit 1 and the exact owner-already-exists error; -resident state SHA-256 remained -`8EA6CD6C30C6D2D64F850585D865B342493CEFD04C34D5870D65DFE506E1190A`. - -Heartbeat tick then completed without changing the resident hash. Bounded -Heartbeat serve acquired `heartbeat.cc.heartbeat.process.lock`, emitted one -pulse, and stopped cleanly while resident Self remained live. Resident SIGTERM -exited zero in 483 ms with final `braked`. Receipts are under -`.epiphany-run/resident-lock-c930f505/` and container logs are retained. - -## Warm package acceptance and resident-owner lock — 2026-08-09 - -Construction-owned Cargo home is accepted. Exact `9f369528` migration release -`sha256-154af0ef9a729f7f46876f99add6828d7e5503f3ecc949ac791f00f26017beca` -with witness `sha256-9b670a4acca14480840da3f09fd83ff5c97829b19f81bd6037c59c9146548cec` -took 15m04s once. The identical warm replay took 10.17s wall, Cargo 1.38s, -and passed independent 24-binary inspection without warnings or collisions. - -Do not describe the resident store as globally single-writer. Heartbeat and -authenticated operator admission own separate typed CAS entries. The proven -fault is that Unix `resident-self` singleton locks use container-private temp -directories. Current source places role-specific process locks beside the -mounted store, preserving Heartbeat's distinct role lock. Windows focused -tests pass; package once and prove two-container exclusion on Linux. - -## Corrected shutdown replay and Cargo-home ownership — 2026-08-09 - -Exact `b8138a6b` release `sha256-f3e0966333b86181bf13893a45f7636d0c6ff13720fbf535b29cca485c3fd58d` -with witness `sha256-4652c86f4a5560475de597fd162dfc7a5369df711cd00e51a3805e769b68a0ee` -passed native 24-binary inspection. Frozen coordinator PID 88 retained pending -SIGTERM, resumed, terminalized, and the resident exited zero in 1.613 seconds -with final `braked`. Restart reached `sleeping`; idle SIGTERM then exited zero -in 871 ms with final `braked`. Receipts are under -`.epiphany-run/shutdown-active8-b8138a6b/`. - -The exact package took 19m26s. The Docker recipe mounted a Cargo-home volume at -`/cargo-home` without setting `CARGO_HOME`, so fresh containers still updated -and downloaded through throwaway `/usr/local/cargo`. Release construction now -owns `build_cache_root/cargo-home` and exports it to Cargo. All 19 focused tests -pass. The first exact build after this change is a one-time source-path -migration; require a second warm replay before claiming the iteration fix. - -## Active resident shutdown proof — 2026-08-09 - -Exact authenticated `00ee3821` idle SIGTERM exited zero. In the active proof, -the packaged coordinator was frozen as PID 103, PID 1 received SIGTERM, the -child retained pending termination, and resumption terminalized the child -before the resident exited zero in 2.023 seconds. The packaged operator -projection nevertheless reported `failed`; source now maps shutdown -cancellation to `Braked`, with a focused invariant test. Package and replay -that exact correction once. - -An attempted live admission also proved that a second process can write typed -pressure which the resident's in-memory state later overwrites. Preserve the -active6 receipts. This is a resident-store single-writer/command-ingress seam, -not permission to add a retrying sidecar writer. - -## Release-construction bootstrap extracted — 2026-08-09 - -Commit `76afdaf0ce863f19e9396ef4d21ed8ff3fb39690` moves package -construction, filesystem verification, and witness inspection into -`epiphany-release-construction`. `epiphany-core` retains only live CultMesh -publication, load, and authentication. The bootstrap graph contains no -`epiphany-core`; all 19 construction tests pass and the core test harness -compiles. Exact Linux bootstrap fell from 7m57s to 30.24s cold and 4.40s warm. - -The narrow tool then produced warning-free 24-binary release -`sha256-30caab9ef1ea89f9a885d87832b1e312a35288ec3f895bd5b0e83f7f7a6a1aec` -with witness -`sha256-89c2ad604254faec3e1e01f753b5dff38a402f43d009074ba4b47b1ec46fdecf`. -Cold Cargo took 12m16s. The identical warm replay took 10.16s total with Cargo -at 0.82s and reproduced both identifiers. Independent narrow-tool inspection -accepted both copies. The packaged full publisher then accepted the same -witness and changed c005's local Verse hash from `b160c610...3909` to -`83ed430f...ae81` without activating the body. This proves construction and -publication remain interoperable while owning distinct consequences. - -Next assign graceful signal ownership. Shutdown must prevent new work, preserve -an unclaimed prepared launch for restart, signal an exact active child, record -shutdown terminalization without failure pressure, and exit zero only after no -child remains. Prove both idle and active paths against copied typed stores -before replacing c005. - -## Exact 24-binary release published — 2026-08-09 - -Exact pushed source `f00c8279c966c43c6ac899d9b16280f373b45941` -completed a warning-free 24-binary Linux package in 18m44s of Cargo work. The -authenticated release is -`sha256-a7c4c2e305257664e9fe2eb64fdd5ba9e7bcb3491c5697e95082c4a3713b579e`; -its witness is -`sha256-e9984086452ae0d4887f7ab63d111469d1f801fd7712c2441611bf5793b889b8`. -Independent native inspection accepted source, inventory, hashes, and private -state exclusion. The identical warm replay completed in 10.64s total with -Cargo at 0.92s, reproduced both identifiers exactly, and passed a second -independent native inspection. Receipts live under -`.epiphany-run/linux-package-f00c8279-{3,warm}/`. - -Native publication inserted the release and head into c005's main local Verse -without replacing the running 9b8df0b4 body. `local-verse.cc` changed from -SHA-256 `d88bb300f8db589f3f82fcba6781b9eb1e9828f22a55684fdaaba0e8a68dcf0d` -to `b160c610988753278afbad7f5bad436193144a92e9fd506982099ad58d213909`. -Availability does not own activation. - -The remaining iteration tax is now precise. Rebuilding the exact release -publisher first took 7m57s because `epiphany-release` imports packaged-release -construction from monolithic `epiphany-core`; the package command then builds -that core again inside the 24-binary graph. Extract construction and witness -inspection into a narrow crate/tool, leaving live Verse publication as its own -authority. Prove the cold bootstrap reduction without changing release or -witness authority, then resume graceful SIGTERM ownership. - -## Resident continuity, topology repair, and build-free status — 2026-08-09 - -Authenticated release `sha256-d1392730...` is now the running c005 body. The -old body and the first replacement container are retained as rollback receipts. -Both Docker stops sent SIGTERM and ended in exit 137 after timeout, proving that -`epiphany-swarm serve` has no graceful signal owner even while idle. - -The first replacement preserved resident Self revision 6, sleeping state, no -active turn, and no prepared recovery, but native status exposed a live topology -fault: resident Self used `/state/runtime.cc`, whose next action was -`launchResearch`, while the accepted coordinated cognition chain lives in -`/state/eyes-tools/runtime.cc`. The resident was rebound without copying or -merging state. Release authentication remains `/state/local-verse.cc`; runtime, -coordination Verse, and Mind now use the established `/state/eyes-tools/` -stores. The current container ID begins `f0303137`; rollback container -`epiphany-linux-resident-self-c005-wrong-runtime-0934` preserves the bad binding. - -Post-rebind operator projection derives `awaitFrontierProposal`, terminal -frontier planning, accepted Research, and `modelingResultAcceptedAfterResearch`. -Route `817bf422...` appears only as the route named by relinquishment receipt -`repo-frontier-relinquishment-7b846272...`; it is not actionable or recreated. -The obsolete root runtime hash remained -`c10caa321322632111a4e8f69550be4c799d78c92a78780a3066bbf6ad0a7c7c`. - -The diagnostic itself exposed hidden build authority: standalone -`epiphany-mvp-status` invoked Cargo whenever optional Heartbeat/Persona/Void -helpers were absent. That fallback is deleted. Optional panels now report -unavailable, `--coordinator-only` performs the exact routing read, and status is -the 24th explicit packaged binary. Heavy OpenAI and MCP runtime dependencies are -feature-admitted so coordinator/status iteration does not compile them. Focused -proof passes 19/19 release tests and 3/3 status tests; warm runs complete in -about 1-4 seconds. Exact 24-binary packaging remains next, followed by graceful -shutdown ownership, restart proof, retention, logs, and endurance. - -## Deterministic warm release published — 2026-08-09 - -Exact pushed source `9b8df0b487eaae12e35dbe53a82faae1a1e39954` -packaged without output-collision warnings in 12m46s after the sole-owner cut. -Native inspection accepted all 23 binaries in release -`sha256-d13927303c957db6799135a61ce6a2899235c397b525968be0bffc3b5ad2a831` -with witness -`sha256-d07277cb5f142a4cc90e9364da0bd058eeba8c524eaf8c00bd9d55f088c78de0`. -The identical warm replay completed in 10.73s total, with Cargo at 0.97s, and -reproduced both identifiers exactly. Native inspection independently accepted -the warm copy. - -The native release publisher added this exact release to c005's local Verse -while the resident process remained live. Before publication, -`local-verse.cc` was 43,849 bytes with SHA-256 -`60872eb9222485c00ccb0c423776f85bacaf2521ed9b80d1bcceccfb319b8eaf`. -After publication it is 51,311 bytes with SHA-256 -`d88bb300f8db589f3f82fcba6781b9eb1e9828f22a55684fdaaba0e8a68dcf0d`. -The running c005 body is still pinned to the older authenticated release. Next: -commit this evidence, then perform a supervised stop/body replacement/restart -against the existing stores and prove continuity resumes at -`awaitFrontierProposal` without recreating relinquished route `817bf422`. - -## Sole packaged executable owner — 2026-08-09 - -Exact `fe6bf006` cold packaging proved the single-process graph and produced -native-inspected 23-binary release -`sha256-7e579b3d78e7de4a8bf161125908ac41d2b9582aba24b5f5be6922d6a4940db0` -with witness -`sha256-45215f5d27d8edb5be877aad769ccd7ac971952d343dc516dea744ee4f82533a`. -The cold conversion took 36m55s. Its identical warm rerun took 11.05s total, -with Cargo completing in 1.26s, but produced a different valid release and -witness. Cargo reported output filename collisions between the selected -`epiphany-release-bundle` and `epiphany-core` packages. Four binaries differed: -`epiphany-hands-action`, `epiphany-persona-mouth-identity`, -`epiphany-repository-body`, and `epiphany-workspace-coverage-projector`. - -The live authority correction makes `epiphany-release-bundle` the only package -selected for witnessed binaries. It now declares `epiphany-state` alongside the -other 22 release targets, still using the core-owned source and library. The -core package remains a developer binary surface but is no longer a packaged -executable writer. All 19 focused tests pass. Commit and push this cut, rebuild -the exact packager, then require a warning-free exact package and byte-identical -warm replay before publication. - -## Deterministic single release graph — 2026-08-09 - -Exact pushed source `e9465c11208d648440999903770cbde245c1da3b` -produced authenticated release -`sha256-5f90294fb037ff777ca99f345e0f4b1e082b176c35bd6e16a60b46d5a687c0cb` -with witness -`sha256-403a4dd4705772d8d588f3abedb336436b9f1b4ebc037b86efbc5995f5d6a291`. -Native inspection accepted the exact source and all 23 required binaries. The -packaged `epiphany-state` hash is -`8e5e0edd3af59a9f8710d4b6b3a7fbe8243f1002acd6e1d4c415e8053d0cd7c2`. - -The cold package took 24m22s: 17m03s for the root graph and 6m38s for the -separate state-steward graph. The identical cached rerun was worse at 28m30s: -21m04s for the root graph, 34.62s for the coordinator graph, and 6m42s for the -state-steward graph. It also produced a different authenticated release, -`sha256-4700e984410e0c8e735d1fcecec282235ed5d096d20b6dbbdb206a83636228fa`, -with witness -`sha256-f71519f7a27a9588715daf9f11d33031b2680659aa405c29807a39efcfcce373`. -Twenty-one binaries were byte-identical; only `epiphany-model-runtime` and -`epiphany-persona-service`, both from `epiphany-openai-runtime`, changed. The -old packager was oscillating one target cache through three feature graphs, -and incremental release codegen made the authenticated output nondeterministic. - -The source cut now uses one Cargo command for both first-party packages, the -coordinator feature, and all 23 explicit binaries, with `CARGO_INCREMENTAL=0`. -The separate coordinator and state-steward build authorities are deleted. All -19 focused packaged-release tests pass. The cold Windows harness took 3m38s; -the final source rerun compiled in 47.87s and executed in 0.83s. Commit and push -this cut, then require an exact Linux package and an identical warm rerun with -both materially improved time and exact release/witness equality before -publication. - -## Unified Cargo authority and shipped state steward — 2026-08-09 - -The first exact `6808f3f5` package attempt failed before release construction: -the one-time `cargo generate-lockfile` had advanced `allocative` from 0.3.4 to -0.3.6 (and its derive/ctor companions), which is semver-accepted but -incompatible with vendored Starlark's `hashbrown` Allocative implementation. -No release or witness was emitted. The root lock is corrected to the previously -proven trio `allocative 0.3.4`, `allocative_derive 0.3.3`, and `ctor 0.1.26`. -A release-target `cargo check --release --locked -p -epiphany-openai-auth-spine` traversed Starlark, Codex protocol/login, and the -auth spine successfully in 3m16s. Commit and push this lock repair, then advance -the clean Linux package source and retry once; do not reuse the failed package -as evidence. - -The root manifest is now the single first-party Cargo workspace and root -`Cargo.lock` is the sole dependency-resolution authority. Seven child lockfiles -and three now-ignored child patch declarations were deleted. Vendored Codex and -CultCache retain their own explicitly excluded workspaces. A source guard in -the release packager rejects a missing first-party member or a regrown child -lockfile. - -The exact stale-CRRC policy regression paid a one-time 5m02s first-party -workspace migration, then reran identically in 4.47s. `epiphany-state` remains -owned by `epiphany-core`, built on the same target in 23.20s, and appended typed -evidence without another graph; a full status read including container startup -took 1.12s. The rejected attempt to place it in the root release package was -stopped because that would drag the root monolith into a narrow ledger tool. - -The native release packager now witnesses `state-steward` as the 23rd required -binary and builds it explicitly from package `epiphany-core` on the existing -release target. All 18 focused packager tests pass. The one-time core test -harness cost 5m33s; an identical warm run took 4.43s, and the final source -increment rebuilt/tested in 20.10s. Receipts live under -`.epiphany-run/unified-build/`. Next package the clean committed source and -prove a warm identical 23-binary release before resuming resident endurance. - -## Stale CRRC authority cut and copied c005 replay — 2026-08-09 - -Self no longer lets a failed reorientation result older than typed frontier -relinquishment `repo-frontier-relinquishment-7b846272...` route the next organ. -The status owner compares the latest bound reorientation job update with the -relinquishment timestamp. Coordinator status demotes only stale manual-regather -pressure to routing Continue; raw CRRC remains published as -`regatherManually`. The focused causal regression passed 1/1. - -A collision-safe copy of c005 `state/eyes-tools` was replayed for thread -`linux-eyes-tools-c005`. It derived `awaitFrontierProposal`, -`canAutoRun=false`, and target Imagination while source signals still reported -raw CRRC `regatherManually`. The live c005 store was not mounted. Receipts are -under the directory named by `.epiphany-run/stale-crrc-replay-current.txt`; the -valid proof is `replay-c005-eyes-output.log`. Earlier root-store/fresh-thread -replays are rejected-path receipts, not c005 evidence. - -The independent `epiphany-self-policy` lock graph paid 6m34s for this one cold -test. A misconfigured Docker invocation then omitted `CARGO_TARGET_DIR`, -compiled into `/workspace/target` for 17m48s, and was proactively stopped with -logs preserved under `.epiphany-run/stale-crrc-build/`. With the target, Cargo -home, and Rust proxy path explicitly separated, the coordinator rebuilt in -37.55s. Encode that contract in one native launcher and collapse the policy -test plus state steward into the root dependency authority. Do not add another -cache. - -## Resident Mind terminal adoption and warm package proof — 2026-08-09 - -Exact pushed source `bd96305e60428b8ea2af822f1e1a233405c09c43` is packaged and -published as -`sha256-01dbed4b015dabccc6f17df49118bba90195993da002f109bafd73f23b1d3a8f` -with witness -`sha256-c3ab5a602de9c58e3ffb23cc5d316e5e36d94a013a697a113af01b4b2cf00808`. -The first package completed its release graph in 25m12s and its isolated -coordinator phase in 33.53s. It followed a host incident where -`C:\Users\Meta\.cargo-target-codex` occupied roughly 276 GiB, filled `C:`, and -caused rustc and Docker backend SIGBUS failures. `cargo clean --target-dir` -reclaimed the target, restored roughly 252 GiB free, and Docker was recovered by -terminating only `docker-desktop` WSL before restart. Preserve the preflight and -SIGBUS receipts under `.epiphany-run/linux-package-bd96305e/`. - -The identical package was then rerun against persistent volumes -`epiphany-linux-package-source`, `epiphany-linux-package-cache`, and -`epiphany-linux-cargo-home`. It completed in 9.65 seconds wall; Cargo reported -0.81s for the ordinary release graph and 0.65s for the isolated coordinator, -and reproduced the exact release and witness. Receipts are under -`.epiphany-run/linux-package-bd96305e-warm/`. This proves the fast shakedown -path is stable cache retention plus free-disk/cache preflight. Do not clean or -partition the shared package graph for routine iterations, and never build this -graph on Yggdrasil. - -The typed evidence append exposed a separate build boundary: `epiphany-state` -is not among the 22 shipped binaries, and building it standalone against the -same exact source/cache took 7m11s. Do not solve this with another graph cache. -Ship the state steward through the owned release graph or move its narrow typed -ledger-write port into an already-shipped native owner. - -The published repair completed the resident frontier-planning chain. Typed -failure review -`frontier-planning-failure-review-4824d856-876f-432c-8fdd-664728938105` -superseded failed Mind job `8e5952fb-0db6-460c-b061-c75d32410cc2` and authorized -one retry. Mind job `2d2a3e8b-77f0-4f57-9125-ec3305a95843` returned a valid -typed adopt judgment without tools or external consequence. Self committed -terminal decision -`repo-frontier-plan-decision-e7d7f3c79595e09f2d2cd9e7c4614909e803b1f9b509f0fc1482d3aaab2ad6d3` -against the original candidate. The next typed action is -`continueImplementation`; execute only that admitted Hands frontier. Do not -recreate Eyes, Modeling, Imagination, either failed Mind attempt, or the -successful retry. - -Hands gate `hands-intent-linux-eyes-tools-c005-0-2ad7b2ce-...` exposed the -candidate's exact rollback: discard the planning draft if later evidence shows -the coordinated resident circuit already exists. Current canonical state and -c005 receipts satisfy that condition, while the runtime artifacts needed to -reconcile it are outside the adopted safe paths (`notes/fresh-workspace-handoff.md` -and `state/map.yaml`). Hands therefore produced no mutation and recorded typed -refusal `hands-refusal-4cd85889-17d0-4d26-8a95-07d04a5cdabf`. Mind atomically -retired route `repo-frontier-route-817bf422...` through relinquishment -`repo-frontier-relinquishment-7b846272...`, advancing RepoModel revision 2 to 3. -The next coordinator snapshot falls back to historical CRRC -`regatherManually` from the old failed reorientation worker. Treat that as a -routing-precedence wound, not fresh Eyes evidence and not authority to recreate -the retired route. - -## Packaged Body speed proof and resident Mind identity correction — 2026-08-09 - -Exact pushed source `217dd4b96746536e01dc8991b5e6f31c2c588af0` is packaged as -`sha256-3dab68c572519501c3401a8b737603e312349a4052f69f7f751478fa2631aaf3` -with witness -`sha256-2278ec15ed44a21e4bc4d20b4f64d67fb530c4bc2bc44cd1cd9d775b16838f74`. -The exact packaged observer reread the unchanged resident c005 Body as -generation 1/tree `4d1f8a23558d53622ed21be0bb51db456b532f48` in 94,521ms. This is -strong observer-boundary evidence against the old 160,183ms Modeling -`jobCommit`, but not a coordinator-to-coordinator replay because Self's typed -route had already advanced. Receipts are under -`.epiphany-run/linux-package-217dd/`; do not rebuild this release. - -The resident chain completed `startFrontierPlanning`, then native Imagination -job `f62738f1-a819-431a-a454-c0b2cff5a4d8` produced candidate -`repo-frontier-plan-candidate-28f597414331a67b71449bcf28317c42ddbd78566dbe92aa41b9f54302762be8`. -Self committed Mind request -`repo-frontier-plan-mind-90e8c1995805d94d05c9e065a117c54eb8993cd93c985b9daa2915746c32977f`. -Mind attempt `411e73bb-4906-4785-be92-2a72a9290691` failed identity validation, -was explicitly superseded, and authorized one retry. Retry -`8e5952fb-0db6-460c-b061-c75d32410cc2` failed with `Mind result request -disappeared`. Direct read-only binary inspection proved the exact canonical -request, planning request, and candidate keys remain in `runtime.cc`; the model -had substituted an unknown echo. Both failures are immutable evidence. - -The authority fault was in source: `RoleWorkerResultIngress` allowed model JSON -to author the outer Mind request echo plus five identities inside the typed -decision. `epiphany-openai-runtime/src/lib.rs` now derives request, planning, -Imagination-result, candidate, and candidate-digest identities exclusively from -the authenticated `RepoFrontierPlanMindContextProjection`. The model owns only -decision, rationale, and its proposed timestamp. A regression supplies five -counterfeit model identities and proves the runtime emits the canonical launch -identities; all 15 runtime library tests pass. Package once, explicitly review -and supersede failed retry `8e5952fb`, and launch only the newly authorized -attempt. Do not recreate Imagination or either failed Mind attempt. - -## Linux Eyes-to-Modeling acceptance and Body observation speed cut — 2026-08-09 - -The fresh tool-enabled resident circuit under `/state/eyes-tools` completed its -causal organ chain. Eyes job `eaf25324-3d4c-49c1-a93d-65f16b080806` used three -governed native read-only source tools, emitted typed result -`result-worker-eaf25324-3d4c-49c1-a93d-65f16b080806`, and was accepted as -`ev-research-856fb6d1-17eb-4d71-bafc-774277e9b64e`. Self then derived -`launchModeling` because accepted Research was newer than Modeling. Modeling job -`3333e537-7451-4cfd-92bf-b69030b2ab4f` used three governed read-only tool rounds, -emitted `result-worker-3333e537-7451-4cfd-92bf-b69030b2ab4f`, and was accepted as -`ev-modeling-11da531d-3403-41a1-93c3-7224d364364a`. Typed status now reports both -`modelingResultAccepted` and `modelingResultAcceptedAfterResearch` true, so the -single-use route was consumed. The next action is `startFrontierPlanning` for -Imagination. No external consequence occurred. - -The Modeling circuit peaked at 109,887,488 bytes over 2,025 cgroup samples. -Its launch receipt measured `jobCommit=160183ms`; process inspection showed the -time inside the first of two full `git add --all` Repository Body scans. The -observer formerly created a brand-new private index and object quarantine for -each equality scan. The current source cut gives one observation session sole -ownership of one private index/object quarantine, initializes it from HEAD once, -and runs both full scans against it. Scan two still performs `git add --all`, -`write-tree`, staged-entry enumeration, and raw-byte manifest hashing, so the -stable-equality invariant remains intact while Git may reuse its verified stat -cache. All 25 focused `repository_body_observer` tests pass, including explicit -proof that both scans share one private index and that session teardown removes -it. The live-worktree mechanism benchmark measured cold scans at 2,176ms and -1,656ms versus a shared -session at 1,414ms and 123ms: 3,832ms fell to 1,537ms, a 2,295ms / 60% pair -reduction. The ignored receipt is `body-index-benchmark.stdout.log`. This is -mechanism evidence, not yet packaged coordinator evidence; package once and -remeasure exact `jobCommit` before claiming the 160-second live wound closed. - -Two attempted detached launches were refused before state mutation. The first -used a nonexistent container path. The next two reached the artifact cleanup -guard from `/`, so the guard correctly rejected `/workspace/.epiphany-smoke` as -outside its process-relative safety roots. The successful launch explicitly -used Docker working directory `/workspace`. Preserve these as operator -intervention receipts; they prove the guard rather than runtime corruption. - -## Linux resident coordination phase boundary — 2026-08-09 - -Exact pushed source `c0055772750a7dd7335f65baa88307cf9e28c1e1` is packaged for Linux as -`sha256-b4faf5721a8662b30464dacb9bcc0945b34051521af110ab3d56eef59036ba7e` -with witness -`sha256-7ddc54e0817efdcc56b6ceb5dc62124502da0d178f1946db7a8e0283a23ecaa0`. -The cold root package took 12m33s plus 18.67s for the isolated coordinator and -exceeded 4.4 GiB; the exact warm package took 9.08s wall and reproduced the -same release and witness. Preserve Docker volumes `epiphany-linux-cargo-home`, -`epiphany-linux-target`, `epiphany-linux-package-source`, and -`epiphany-linux-package-cache`. Yggdrasil must not build this graph. - -The isolated resident body is under `.epiphany-run/linux-resident-c005/`. -Packaged Repository Body bootstrap initially refused a foreign swarm ID, then -succeeded with authoritative Mind swarm `gamecult.epiphany.main`. The successful -pass ran from `23:10:34Z` to `23:15:50Z` and visibly performed two full-tree -`git add --all` authentication passes. Its receipt is -`body-bootstrap-success.log`; the identity refusal is -`body-swarm-identity-refusal.log`. - -Heartbeat pulse 1 issued the original grant. Self first failed because the -artifact root was mounted outside the coordinator's canonical -`.epiphany-smoke` cleanup root. The typed cancellation returned pressure to -pending; heartbeat pulse 2 acknowledged the exact terminal ID and issued -attempt 2. With the same host artifacts mounted beneath -`/workspace/.epiphany-smoke`, Self completed revision 6 and returned to sleep. -This proves authenticated Linux heartbeat -> Self -> plan coordinator -coordination. The plan coordinator intentionally invoked no model or tools. - -The next execute pass exposed process ownership. A one-shot coordinator -container opened reorient job `8870f824-fdf9-4240-996a-6a663cead22c`, detached -its model worker, and exited; Docker then killed the worker because PID 1 was -gone. Exact-job recovery inside the resident container correctly refused the -still-open inner job and sealed both outer and inner jobs failed. Do not replay -that job. Receipts are in `execute-bootstrap-refusals.log`, -`coordinator-execute-reorient/`, and `linux-reorient-recovery-summary.txt`. - -CRRC next routed Eyes. Resident Eyes job -`ab813c57-081a-4c62-80e5-d3471ae451bf` reached a real OpenAI Codex request with -three native read-only source tools advertised and no external consequence. -Because the bounded objective promised no tools and coordinator ran with -`--no-auto-tools`, the model-selected tool path had no tool loop; assistant text -was empty and the `epiphany.worker.role_result.v3` parser failed closed. The -failure was superseded by typed receipt -`role-failure-review-859fa955-4fee-4dd5-a0a4-d75b769890be`. No tool invocation -receipt was admitted. The resident cgroup peak across Self, coordinator, and -model worker was 62,590,976 bytes (59.7 MiB), captured in -`linux-eyes-memory-summary.txt` across 54 100ms samples. - -Auth residue audit found no copied `auth.json` and zero matches for access or -refresh tokens. The private runtime store contains the mounted auth file's -ChatGPT account identifier as model-transport identity metadata; no artifact or -workspace file contains it. Do not describe the store as credential-free -without this classification. - -GameCult ops commit `812b427` repairs the uninstalled Yggdrasil resident service -contract: it provisions a root-owned empty MCP policy, supplies the required MCP -and Persona-classification arguments, moves coordinator artifacts beneath the -workspace's ignored `.epiphany-dogfood` root, and replaces the removed -`epiphany-tool-codex-mcp-spine` name with packaged -`epiphany-tool-mcp-runtime`. The normalized Linux wiring test and shell syntax -checks pass. Nothing was deployed or started. - -Next: preserve this zero-tool circuit as sealed evidence. Create a fresh typed -objective/adoption boundary for a Linux Eyes circuit that explicitly permits -native read-only source tools, run it inside the persistent resident body, -prove tool receipts plus a valid typed role result, review/accept it, and inspect -the next routed organ. Do not rewrite the existing authoritative objective; the -coordinator correctly refuses that. Do not reinstall or start the Yggdrasil -service body merely because its static contract is now coherent. - -## Retention and release-bootstrap pass — 2026-08-08 - -Exact corrected release `100d8854` packaged 22 binaries as -`sha256-da8be22948c6eb958edb2e7f7e03c5cc77d17463659fa14127402392194460d3` -with witness -`sha256-6a95957f7e7b2b47b42d2154ed8232d68ffe68d3b6bdf67bee6397fa6aab2027`. -Its packaged runtime-spine closed all four sessions in a fresh byte-identical -v28 copy, replayed closure idempotently, and refused post-close work. A bounded -live retention drain then reduced heartbeat artifacts from 12,511 directories -and 706.5 MB to 312 directories and 17.6 MB. The latest cognition pulse -survived; 191 deletion receipts are in the heartbeat store and the drain log -SHA-256 is `8280dd7567f839b0b038d69deb45bfb219c42092a231a2d331e0e3620a293003`. - -Restarting the resident under `100d8854` exposed another Continuity fault: -serve iteration restarted at `pulse-000001` instead of recovering the highest -surviving sequence. The process was stopped after three pulses; its stdout -SHA-256 is `4a104e39d81e0766261fff815a7d4350de31a9d5b956634a9cb39a9e5ad40b22`. -Current source resumes from the highest exact pulse directory, refuses alien -directories and exhausted sequence space, skips protected current cognition -when forming retirement batches, and emits named operator receipt fields. Four -retention and three heartbeat-binary tests pass. The resident heartbeat remains -stopped pending an authenticated package of this correction; do not restart the -old binary. - -That correction is now exact-package live-proven. Commit `42bc665a` packaged -release `sha256-f68fb664ee67af4c665c9a1c6162422a8944cc3b5771e4b6b1c90c23c63c48e8` -with witness -`sha256-d9c00bc57408ba8d1c9f74a09364c513819122f127fdb5888c93c8dbc68b694e`. -Its resident heartbeat resumed at pulse 012558, crossed the 320-directory -hysteresis edge at pulse 012561, emitted a named 64-directory retention receipt -for 3,615,104 bytes, continued to pulse 012562, and left 258 directories. The -three quarantined reset-era pulses were retired in that receipt. PID 19928 owns -the live process; logs are -`.epiphany-run/resident/heartbeat-v8-42bc665a.stdout.log` and `.stderr.log`. -Warm exact packaging after the root target-set transition measured 1m12s stable -phase plus 6.56s coordinator, confirming the prior 7m19s pass was a one-time -target-set relink rather than the new steady state. - -Endurance baseline -`.epiphany-run/resident/endurance-baseline-42bc665a.json` was captured at -2026-08-08T22:08:50Z: heartbeat PID 19928 used 11.8 MB working set / 3.0 MB -private memory, heartbeat store was 1,507,503 bytes, resident-Self store 7,844 -bytes, artifacts were 269 directories / 15,195,150 bytes, heartbeat stdout was -8,804 bytes, and stderr was empty. Compare future observations to this exact -artifact. Do not call direct file truncation log rotation: the current child -holds stdout/stderr handles and the launcher exits after spawn. Idunn's managed -service reconciler is the likely owner, but its current policy only opens files -at launch and has no typed size/segment authority. Map that ownership before -adding a restart timer or log helper. - -The first exact `339d5a6f` build completed its Rust 1.95 graph in 17m07s but -failed because the isolated coordinator artifact was absent. Rebuilding that -single target restored the cache. A detached clean-worktree retry then exposed -the actual iteration defect: release source-cache identity was checkout-path -owned, so identical source under another worktree invalidated Cargo's absolute -path fingerprints and repaid 11m12s of workspace compilation and linking. -Current source keys exact-source cache ownership to Git's common repository -while preserving the original main-worktree identity; a linked-worktree test -proves the two views share one cache. - -The resulting `sha256-cb91f60e...` package and published witness are sealed but -rejected as Continuity evidence. They were assembled by the pre-correction -debug publisher and contain the old 21-role body without -`epiphany-runtime-spine`. Inspection then found the deeper bootstrap omission: -`339d5a6f` added the role mapping but did not expose the actuator in the root -release-bundle manifest. Current source adds that binary and makes the release -test prove root-manifest presence. The current publisher, runtime-spine, and -heartbeat binaries compile from source; all 17 release tests and all four -retention tests pass. Package only after committing this corrected body. - -Heartbeat pulse artifacts now have a Continuity-owned typed retention route. -Above a 256+64 hysteresis boundary it plans exactly 64 oldest pulse directories -with recursive SHA-256 manifests, writes the plan through exact CAS, deletes -only byte-identical planned members, and writes a typed completion receipt. -Pending plans recover after crashes. Unknown directories, symlinks, changed -members, root escapes, and the latest cognition artifact fail closed. The same -primitive serves the explicit command and resident heartbeat loop. No live -artifact has yet been deleted; stdout/stderr rotation remains a separate -supervisor-owned front. - -## Continuity closure pass — 2026-08-08 - -Sealed v28 remains immutable at -`F:\Projects\.epiphany-runtime\shakedown\live-20260807-v28\runtime.cc`, -2,378,654 bytes, SHA-256 -`df9d707f1a87dcf557ad638c7baf8136d9db6f72b35d57abe96759088331f864`. -A byte-identical disposable copy under -`.epiphany-run/continuity-v28-replay-20260808/` reproduced dead Imagination job -`b34d21de-6788-4935-8910-75275c257444`. Authenticated release `55660d78` -terminalized that outer job as failed with result -`result-worker-b34d21de-6788-4935-8910-75275c257444`; the copied runtime then -reported nine jobs, nine results, and zero open jobs. A second worker start was -refused because the job was already terminal. Adapter-status refresh changed -the store hash during that refusal, so job/result identity—not whole-store -byte equality—is the restart invariant. - -The replay then exposed a separate architectural hole: all four v28 sessions -were still active because the runtime spine defined `Completed` but supplied no -completion owner. The current source adds Continuity-owned session closure, -`list-sessions`, and `close-session`. Closure refuses open jobs and archived -sessions, emits deterministic `session.completed`, is idempotent for an already -completed session, and prevents later job creation. The focused core test -passes. The disposable v28 copy now has zero active sessions and four closure -events; its final SHA-256 is -`06179384829bda33dfb5df78dc0923a545598ddf73e33c674abe96934f2713c5`. -Package and publish the source cut next, replay with the exact package, then -begin bounded retention. The Discord credential and stable Windows firewall -rule remain separate open fronts. - -The first `230f71f4` package attempt was deliberately terminated after 211 -seconds. It had correctly opened a new Rust 1.95 graph namespace, but inspection -showed `epiphany-runtime-spine` was absent from the release's required binary -set. The resulting package could not expose the session-closure actuator and -therefore could not prove its own Continuity claim. Rejected build progress is -preserved in `.epiphany-run/package-230f71f4.stderr.log`. The current source -adds `runtime-spine` as a required authenticated release role; all 17 packaged -release tests pass. Commit and package that correction instead of resuming the -invalid `230f71f4` build. - -Epiphany remains a supervised engineering alpha. Starfire is the cognition and -release forge; Yggdrasil is the small live crossing host and is not a build -machine at its current memory budget. - -## Authoritative state - -- Branch: `codex/epiphany-shakedown-live` -- Latest pushed Epiphany commit: `339d5a6f7ba6cc11a39226f1eb6608da0339e25e` -- Authenticated release: `sha256-2f4a17126d12935088189c32caadef202a1e9b698ec2cfc8fd4aec08c0763696` -- Witness: `sha256-c0788bda36aa28b8025979378968a2c48cbbcc607a1a538351756831c2b287f4` -- Live Bifrost/CultLib runtime: `cb3239aaac963995ad012e648f9a455463a54ea2` / `f67f5122ed1bd11da016e7b820ed60145ccd0299` -- Live workspace: `F:\Projects\.epiphany-runtime\shakedown\live-20260808-v53-hands-precedence` -- Thread: `shakedown-v49-hands-relinquishment-r1` -- Thread-state revision: `59` -- Sealed evidence: v49 through v52. Do not mutate it. - -## Live causal boundary - -Epiphany `55660d78`, Bifrost `cb3239aa`, CultLib `f67f5122`, and CultNet -`2d0988ba` implement and deploy the Starfire-to-Yggdrasil Persona nerve. An -already-durable signed `epiphany.persona_discord_delivery_request.v0` now -travels over a Starfire-initiated CultNet/RUDP session; Bifrost admits it to -its endpoint store, retains permit/journal/Discord authority, and returns its -signed terminal `bifrost.persona_discord_delivery_receipt.v0` on the same -session. Epiphany verifies and durably stores that receipt before terminalizing -the Persona turn. A real Rust-to-Node socket smoke passes, as do all nine -focused Bifrost delivery tests. The shared transport fault was an old Rust ACK -spending an ordered data sequence; CultNet commit `2d0988ba` ports the upstream -sequence-neutral ACK correction. Runtime identity is now deployment-bound to -`epiphany-starfire`, not hardcoded as `epiphany-yggdrasil`. - -Yggdrasil now runs both native feedback and Persona mouth services from the -exact immutable Bifrost/CultLib runtime. Starfire runs the packaged permit -service from the exact authenticated Epiphany release. Public trust anchors -crossed hosts; signing seeds, Discord actuation, and private execution state did -not. The first live Persona request reached model terminal and durable request -state, then its expired recovery produced signed terminal `unknown` without a -second post. It is sealed and may not be retried. - -Live probing then found two cross-language/authority seams. Bifrost had encoded -the permit request as a camelCase map while Rust requires a positional struct, -and decoded Rust's positional permit as an object. Commit `514c2a6` aligns both -wire bodies; a unique permit-only Node-to-Rust-to-Node request now completes. -The second fresh Persona turn reached model terminal and consumed a permit, but -Bifrost called its Discord bridge without the required CultMesh command ID. -The bridge refused the unreceipted actuation and Bifrost correctly signed -terminal `unknown` with no message ID. Commit `cb3239aa` binds the bridge command -receipt to the signed Persona request ID and is live. - -Yggdrasil has no `/srv/bifrost/env/persona-delivery.env` and no -`BIFROST_DISCORD_BOT_TOKEN` or compatible token in managed secret roots. No -third Persona request may be created until an operator-owned bot token is -installed root-only and the mouth restarted. The two existing requests are -sealed non-deliveries and may never be retried. Windows still retains -per-release firewall rules; the admitted prior authenticated permit binary PID -`19024` carries diagnostic traffic, while `gamecult-ops` `e52c7dc` contains the -durable path-independent UAC repair. - -The operator expects proactive operator-enginseer intervention in corrupted -Epiphany runtime state; corruption is not a permission boundary. Repairs must -be labeled, receipted, preserve immutable worker evidence, and use exact -compare-and-swap revision authority. Record the authoritative before state, -the exact intervention, and verified after state. This standing repair -authority restores Epiphany's own invariants; it does not bypass typed gates -for new Discord, deployment, or other external consequences. - -Commit `7093a8b9` supplies that narrow primitive for the legacy accepted Modeling -result which predated the typed future-frontier invariant. Revision 49 was -sealed before correction at -`sealed-evidence/v53-pre-modeling-acceptance-correction/runtime-revision-49.cc`, -76,172,850 bytes, SHA-256 -`5ec47d8da386976dbb8ca1b18f214507de3c14eb4f02d31bdc3aa60d99e612f3`. - -Correction -`supervisor-acceptance-correction-e2ddbf239ea45081138ad9f10089f6895887fe14130b431aab0fef1d1978004c` -removed only obsolete acceptance -`accept-modeling-result-worker-4e6b6022-73ab-49f1-81c8-03dddfceb29f`, retained -its immutable result and admitted RepoModel, and recorded prior receipt hash -`2f1af810e77997e2bf235e779609da62ec1a5148107d81a342288005e80df510`. -The old result was then reviewed under current policy and superseded as -`role-failure-review-a35d6548-ec90-48c6-80d5-84ac6e32c619`. - -Fresh Modeling job `ca61f378-4998-4911-a565-06d77388bb4a` was accepted as -`accept-modeling-result-worker-ca61f378-4998-4911-a565-06d77388bb4a` with -evidence `ev-modeling-4a0caaa3-9172-44eb-a9e9-9ea68c6406fc`. It minted exactly -one active typed Imagination frontier, -`frontier-native-frontier-minimal-route-chain-design-20260808`. - -Self routed that frontier over the stale display-level `regatherManually` -recommendation: - -1. planning request `repo-frontier-planning-7adf9c5863cd3ca640086f9aafd1abd910aa8d28e40dcc6e08835a20af60a9aa` at revision 53; -2. completed Imagination job `2a5701fe-7fbe-4f29-b3a5-51d6e790acbd` and typed candidate `repo-frontier-plan-candidate-02c089eb385c27560252d1915b998efc7c800324971a7b915b6e9ff3d33e4646` at revision 54; -3. dedicated Mind request `repo-frontier-plan-mind-7c8f086d050fe458a298ea4d9f5202e446530e5e14fa10129f52b4ae72238bc3` at revision 55, without adoption or Hands authority. - -Mind adopted the candidate, Self materialized the exact route and scoped Hands -authority, and Hands committed `29797ab8` with typed patch, command, and commit -receipts. The next live typed action is `launchVerification`. - -The first Soul launch failed before worker creation because -`append_verification_hands_receipt_context` treated every admission with a -`result_id` as Modeling. The route admission actually binds Mind plan result -`result-worker-c0815013-7c61-4872-8549-4b666ceb015a` and explicit decision -`repo-frontier-plan-decision-22de32456ea73d63f613e69e8fdca876f5068f06febdc04d9f847da18af65a6e`. -The fresh Modeling acceptance remains present exactly once; the runtime did not -need correction. Pre-repair snapshots are -`.epiphany-run/v53-live-thread-acceptances-pre-repair.json` (SHA-256 -`7f22d49b5b06fa84e5fdfce6066403fab88de6526cc82e4726e9d1343f400b46`) -and `.epiphany-run/v53-live-route-admission-pre-repair.json` (SHA-256 -`df9002fd97d0ecfaf0750c41f397b0f560062132564b8b677d51ca70344518ac`). - -The active source repair types all new plan admissions as -`FrontierPlanDecision`, makes Soul validate the immutable decision receipt, and -uses the already-persisted `frontier_plan_decision_id` as the compatibility -discriminator for v53. It does not rewrite evidence or weaken Soul. - -Authenticated release `sha256-53dc65ecf1971fc39a535c3a597723e02ebe73a28936581441b4fe007c98c601` -from `d2538d46` proved the typed branch live, then failed closed because its -first exact-binding predicate incorrectly equated the decision's pre-adoption -frontier hash with the route's post-adoption hash. The follow-up source repair -binds the decision to the pre-admission model, the admission purpose to the -planning request and candidate, and the route to the admitted model. A focused -positive/negative test proves the real transition passes and a substituted -admitted route hash fails. - -Exact `d3bfbda0` packaged in 29.84s for the stable phase and 5.43s for the -isolated Self/coordinator phase, then authenticated and published. Live -Verification job `f23fe2b6-ad39-41e7-a2c9-4c26d9f5f26c` launched without -overrides, completed in roughly 700 seconds, and was accepted as -`accept-verification-result-worker-f23fe2b6-ad39-41e7-a2c9-4c26d9f5f26c` -at thread revision 57. Soul verified exact Hands commit `29797ab8` and bounded -the claim to the documentation-only route-chain specification. A read-only -coordinator planning pass now derives `launchModeling` because Soul accepted -the Hands consequence. - -Post-Soul Modeling job `972f4e31-9009-4b7d-863d-b2aa0295abf7` launched at -revision 58. Its live launch timings were state load 79ms, dynamic context -66ms, role augmentation 1.053s, job commit 51.482s, total 52.680s. The worker -produced exactly one verdict-incorporation patch; Mind accepted it as -`accept-modeling-result-worker-972f4e31-9009-4b7d-863d-b2aa0295abf7` at -revision 59. The frontier is resolved and the Soul-to-Modeling route is -consumed. Self now falls back to the legacy CRRC `regatherManually` projection; -do not use that historical pressure to reopen this completed frontier. - -## Build-time finding - -Commit `0f0b006d` made the three named owner manifests drive separate locked Cargo -builds. Focused tests passed, but the real benchmark falsified the design: - -- the new aggregate owner-lock identity forced a cold graph namespace; -- the core owner group took 8m02s; -- the OpenAI runtime group then resolved its own dependency graph and began - compiling `epiphany-core` a second time; -- the run was terminated at 16m53s before the tool-runtime group could repeat - the wound; -- logs are `.epiphany-run/package-0f0b006d-owner-groups-attempt2.*`; -- pushed commit `a1a43892` reverts the implementation. - -Do not resurrect separate owner lock universes. The local replacement retains -the one root Cargo graph and moves routing policy into `epiphany-self-policy`. -Stable coordinator contract types remain in -`epiphany-core/src/surfaces/coordinator_contract.rs`; core no longer compiles or -re-exports policy functions. Core explicitly retains all 74 non-coordinator -binaries. The root coordinator target alone enables optional feature -`coordinator-runtime`, which pulls the policy crate; ordinary release binaries -do not see it. Packaging builds ordinary bins under the root lock, then builds -only the feature-gated coordinator in the same target cache. Cache identity is -target/toolchain-stable across lock edits; Cargo owns staleness while the frozen -lock and release witness remain authority. - -Exact `d910158f` is committed, pushed, authenticated, and published to -`.epiphany-run/cultmesh/local-verse.ccmp`. Release -`sha256-2d6672958cd59cae43bbbc17c8218eaf3d50f3acab3b7d6550cb6dfad5f72020` -has witness -`sha256-23d3f44ef0f632dfc52a607585469b7242ac77a489e1406d7b3e2f578979462d`. -The cold stable graph took 17m38s; the isolated policy/coordinator phase took -30.31s. A controlled warm invalidation of the policy source rebuilt exactly -`epiphany-self-policy` and the root coordinator in 6.02s (6.133s wall). All 20 -stable packaged executables retained identical hashes, lengths, and write-times; -the coordinator write-time advanced. The source-cache timestamp used to trigger -Cargo staleness was restored after the measurement. The earlier 1.21s no-op -probe reported `Removed 0 files` and is rejected, not evidence. - -## Current performance evidence - -- Exact `c35272c9` warm packaging of 21 binaries: 2m34s. -- Release-publisher bootstrap after a core edit: 4m11s. -- Exact `d910158f` cold stable graph: 17m38s. -- Exact `d910158f` isolated coordinator phase: 30.31s. -- Warm Self-policy invalidation: 6.02s; zero of 20 stable packaged executables relinked. -- Fresh Modeling context: state load 121ms, dynamic context 107ms. -- Fresh Modeling job commit: 51.637s; coordinator total 51.865s. -- The launch wound is the whole-store transaction, not context assembly. - -## Keyed runtime and packaging cut - -The current uncommitted pass after `b070e121` introduces one runtime-spine -backend owner selected by explicit extension: `.cc`/`.msgpack` retain the -sealed legacy snapshot implementation and `.redb` selects CultCache's keyed -redb implementation. All 29 runtime-spine CAS construction sites and the -coordinator state transaction now resolve through that owner; unrelated stores -retain their existing authorities. Focused backend parity proves successful and -stale CAS on both formats. All eight coordinator transaction tests pass. - -The one-time migration refuses an existing destination, verifies unique typed -identities, writes source envelopes plus a typed in-store migration receipt in -one empty-destination CAS, reads back exact envelope equivalence, and rehashes -the source bytes to prove the legacy evidence was not changed. A disposable -migration of live v53 copied 9,376 envelopes from source SHA-256 -`78eb340a028c88d42770345518d810841029411510a2abab233d9a89761dd5e4`; the -sorted envelope-set SHA-256 is -`bbe288e348ab3a6c8af6d64d205fe818a59218988a493f9751ed65588f2b338e`. -Artifacts and the receipt are under -`.epiphany-run/storage-benchmark-20260808-2/`; authoritative v53 was not -mutated. - -Release-mode live-sized measurements are mixed but promising: legacy full read -563.70ms versus keyed 718.18ms; legacy event mutation 896.91ms versus keyed -363.61ms. Debug redb timings were misleadingly slow and are rejected for -production judgment. Do not migrate live from this proxy alone. Measure the -exact coordinator launch replacement set against the keyed v53 copy next. - -That next probe changed the diagnosis. The durable -`epiphany-runtime-store-benchmark` selects typed historical transaction -envelopes by exact job identity and emits identity/digest/timing receipts on -disposable stores. The surviving launch-request batch for job `972f4e31` was -legacy 785-1,012ms versus keyed 23-32ms; its completion batch was legacy -784-1,567ms versus keyed 21-34ms. Those receipts prove keyed CAS is faster, but -also falsify the claim that snapshot CAS owned the measured 51.482s launch -bucket. Do not migrate live on that old causal story. - -`commit_coordinator_job_launch` performs Modeling-only -`observe_runtime_repository_body_basis` before opening the state transaction. -That observer constructs two isolated Git trees and raw SHA-256 manifests over -3,994 files, then requires exact equality. Direct authenticated release timing -was 92.30s and created Body generation 2. The fresh-index Git phase was only -1.62s; raw file reads and metadata were the wound. Bounded parallel manifest -construction keeps the same per-file before/after metadata checks, raw hashes, -sorted root, isolated trees, and second full equality pass. All 24 observer -tests pass. Direct release observation fell to 49.52s and created generation 3. -This is material but not final; package it and measure a real launch before -claiming the original 51s path is cured. - -Packaging selection was tested by replacing Cargo `--bins` with the explicit -authenticated sibling set while leaving the feature-gated coordinator in its -existing second phase. The focused 17 packaging tests passed. A deliberately -detached release benchmark that missed the shared target directory took 4m41s, -proving that target-cache location must remain tool-owned rather than operator -memory; the authenticated packager already owns a stable graph cache explicitly. - -The real exact `9d671aee` package falsified that selector hypothesis. The first -phase still took 7m26s because root `--bins` already named the 20 stable release -bundle targets; it never linked core's 74 diagnostic binaries. Explicitly -listing the same 20 targets did not reduce fan-out. The change is reverted in -source. Core compilation remains the build-time owner. Exact `9d671aee` is -nevertheless authenticated and published as release -`sha256-6de91b234bdfda1149e48b9fef6710bdd8c4e3274981e4aa88fc46ec109a2e56` -with witness -`sha256-f2c0e464b1523b1a14fb500afa747f0dd95166ebd068752bf639a43827c6b9ba`. - -## Open readiness work - -- cut the measured 51.482s whole-store Modeling job-commit seam; -- prove native Persona cognition and external speech consequence; -- prove Continuity crash, restart, session closure, and bounded retention; -- measure long-duration resource plateau; -- profile and remove the Modeling whole-store commit path; -- prove Linux cognition on Starfire, then size Yggdrasil from measured demand. - -The current Yggdrasil body was inspected read-only at -`2026-08-08T22:12:11Z`. It reports 2 vCPUs, 1.9 GiB RAM, 2 GiB swap with -516 MiB already used, 1.3 GiB memory available, and 14 GiB free on the root -filesystem. `bifrost.service`, `bifrost-persona-feedback.service`, and -`bifrost-persona-mouth.service` are active. Epiphany, its heartbeat/swarm, and -Idunn are absent, matching the current authority map. Yggdrasil may receive a -prebuilt bounded Linux smoke using isolated disposable state; it is not a Rust -build host, and the apparent available memory is not residency evidence while -the host already carries swap pressure. Build on Starfire and measure the -actual Linux process footprint before proposing a permanent Yggdrasil body. - -Linux physiology is now proven without installing the Epiphany service body. -Starfire built only `epiphany-runtime-spine` from exact commit `b5140288` in -the deployment actuator's digest-pinned Rust image -`sha256:4c2fd73ef19c5ef9d54bee03b06b2839a392604fbfcd578ed948b71b37c1d7fb`. -The cold build took 4m25s and peaked near 1.77 GiB inside Docker, confirming -that Yggdrasil must not compile this crate. The dedicated Starfire Cargo volumes -then produced an unchanged warm rebuild in 1.18s. The 6,181,968-byte Linux -binary is -`sha256-14143382fdfb5eb40919facd4bc681613d1a2563e18af08b522d0e5a097880f3`. - -The exact binary ran on Yggdrasil only from `/tmp` against a new disposable -CultCache store. It initialized the typed runtime catalog at 3,968 KiB peak -RSS, refused session closure while a job was open, admitted one terminal -Continuity result, closed the session, repeated closure idempotently, refused a -post-close job, and reported one completed session/job/result with three events -at 4,352 KiB peak RSS. The store was 5,465 bytes with SHA-256 -`f9cccce0b64bb4b282a1fda208d346177cf1a5f91f0e02bbf4f6520c985115cc`. -The script removed the binary, store, root, and itself; a follow-up assertion -proved all four paths absent and the three Bifrost services remained active. -The retained successful receipt is -`.epiphany-run/linux-spine-b514/yggdrasil-success.receipt`, SHA-256 -`5dbf03cbb2e4633464055de888f8417fbd7ad5cfdb4f04ebef34ab53790f5c00`. -The first invocation failed before CultCache initialization because the host -lacks the optional `file` utility; that decorative probe was cut. Its receipt -is retained beside the success receipt at SHA-256 -`b5a55ec37c258ead9ecc745e77c16bb4fa83373b8462e15ff04fd4d8ff659ebe`. -This proves Linux typed physiology and Continuity portability, not Linux model -cognition or resident readiness. - -Basic Linux model cognition is now proven on Starfire. Exact pushed Mind -`a0d56f94` produced a 27,767,120-byte `epiphany-model-runtime` in the same -digest-pinned Rust image. Its SHA-256 and native preflight witness are -`c72f33ed3b429c201eadd9a82b70a71ebce0a6d49901e13bfbefb533e3a972f1` -and `openai-runtime-preflight-c72f33ed3b429c20`. The first real request -completed through `epiphany_direct_responses_http` in 2.60 seconds, emitted two -typed events, returned exactly `Linux cognition is awake.`, and recorded no -tool intent. A fresh measured request completed in 2.26 seconds, returned -exactly `Measured Linux cognition is awake.`, and reached 20,480 KiB peak RSS -across 141 `/proc` samples at 10 ms cadence. Its typed store is 19,574 bytes, -SHA-256 `582b85cbf3c25c4bd23c6583bf43dcca1e2cda8a6956b9294fb441204d8869c2`. -Native preflight reread that store and proved the model request, stream event, -model receipt, and OpenAI receipt document types with no private state exposed. -The auth file was mounted read-only from Starfire and was not copied into the -smoke artifact root. - -The model build exposed a separate iteration defect. The root workspace and -`epiphany-core` manifests resolve version-skewed lock graphs, so the warm core -target did not prevent a second cold dependency compilation. Model-runtime took -10m57s cold and exceeded 4 GiB during parallel compilation. Once that root graph -was populated, the exact warm build took 6.04s. The immediate operational cure -is to preserve both explicit Starfire caches; the architectural cure is one -workspace/lock owner and organ crates small enough that a model-transport change -does not relink the whole organism. Do not hide this split with another cache -alias. - -Receipts live under `.epiphany-run/linux-model-a0d56f94/`. Important hashes: - -- measured summary: - `sha256-fa4b4fc15238fdcf50b2f88430017a0a54430ce6eb905410129aa8f4ff966168`; -- measured assistant text: - `sha256-dfa5ba74b9b51b324847383f8c64e38963439847c32ecce621f1262333503d13`; -- process metrics: - `sha256-702e68b03355a8a8cfeb32bcbebe7154ab7ad3c50ee0c5c0698f30eb70090a71`; -- the rejected object-shaped request failed before opening transport or creating - a store and is retained as - `sha256-0c48d6546e3aad1c13f581ece988fcbdeefd4123023433bfabd11b94590f7f59`. - -This proves individual Linux model transport and cognition. It does not prove -resident Self/heartbeat coordination, aggregate resident footprint, restart, -or Yggdrasil residency. - -Do not recreate prior Eyes, Hands, Soul, or Modeling work. Do not feed the old -manual-regather loop. Use coordinator projections and receipts; raw worker -thought remains sealed. - -## Persona consequence boundary - -Persona is live across both hosts but has not yet completed a public consequence. -Starfire owns temporary Epiphany cognition and the five-second permit; -Yggdrasil owns Bifrost, the Discord binding, the actuator, the private execution -journal, and the signed terminal receipt. - -Current physical state: - -- Yggdrasil runs `bifrost-persona-feedback.service` and - `bifrost-persona-mouth.service` from exact Bifrost `cb3239aa` / CultLib - `f67f5122`; the mouth is bound to WireGuard `10.77.0.1:17876`. -- Starfire feedback ingress uses immutable CultNet snapshot export/import; it - never copies live Bifrost `.cc` state. -- Starfire permit PID `19024` runs the prior authenticated Epiphany release at - the Windows-admitted path and binds `10.77.0.2:17877`; exact `55660d78` - remains published but blocked by Windows' per-release program rule. -- Request, receipt, and permit-request identities are purpose-specific. Only - public anchors crossed hosts; private keys remain with their owners. -- The first live request reached model terminal, persisted on both sides, and - later reconciled to signed terminal failure after its permit intent expired. - It did not automatically repost and must never be reused. -- The second live request obtained a valid permit, then terminalized signed - `unknown` when the bridge rejected its missing CultMesh command ID. It has no - Discord message evidence and must never be reused. The source fix is live. -- Unique permit-only probing completes across Node/Rust; the reusable probe no - longer collides with its own replay key. -- Yggdrasil lacks the token-bearing Discord credential required for actuation. -- Windows currently blocks inbound traffic to the new exact permit executable - with automatic per-program rules. The path-independent scoped repair is - `F:\Projects\gamecult-ops\scripts\allow-starfire-epiphany-persona-permit.ps1`. - -Install an operator-owned bot token as root-only -`/srv/bifrost/env/persona-delivery.env`, restart the mouth, and verify only the -credential's presence. Then queue one fresh uniquely identified Persona mention -and prove model terminal, signed request, permit, Discord message ID/URL, bridge -crossing receipt, signed Bifrost receipt, Starfire admission, and heartbeat -terminalization. Transport acknowledgement is never speech success. Do not -SFTP live stores, share private keys, run Bifrost actuation on Starfire, weaken -the permit, or retry either sealed request. - -## Continuity retention audit — 2026-08-09 - -The source-grounded retention authority map is now in -`notes/epiphany-current-algorithmic-map.md`. Heartbeat pulse directories already -have typed plan/receipt retention and in-store heartbeat history is capped at -128. Resident Self pressure/grant/claim/ack lifecycle rows and runtime-spine -coordinator receipts remain unbounded. The old `ResidentSelfRuntimeReceipt` -shape is produced only by test-only reconciliation and is not a live target. - -Resident lifecycle retirement may touch only a fully closed lifecycle after -Heartbeat has consumed its terminal acknowledgement. It must atomically delete -exact witnessed envelopes, publish typed digest/count evidence with no -scheduling authority, and refuse pending pressure, unconsumed grants, -prepared/active launches, unconsumed acknowledgements, and brake/shutdown -cancellations whose pressure was requeued. Negative proof must show retained -history cannot create pending work or resurrect a coordinator turn. - -Coordinator receipt, Heartbeat artifact, and deployment log ownership are now -settled. Exact packaged `16c4b19f` retired pulse directories 1-2 from a -five-pulse copied-store fixture, retained 3-5 byte-identically, emitted the -typed retention receipt, and replayed `within-bound` without another receipt. -Receipts are under `.epiphany-run/heartbeat-retention-16c4b19f`. - -The live infrastructure repo is `F:\Projects\gamecult-ops`. Commit `059821f` -makes systemd-journald the sole Yggdrasil owner for supervisor and projector -stdout/stderr: both projector policies bind `/dev/stdout` and `/dev/stderr`, -the unit explicitly selects journal streams, and no parallel long-lived files -remain under the Epiphany state root. The optional fatal log is not configured -by the Yggdrasil unit. The full organizational operator wiring suite passes. -Do not reintroduce external truncation beneath inherited descriptors. - -Next: run the measured idle/active endurance plateau, then continue the -remaining organ coordination audit. Broad session/model/event/tool compaction -still waits for typed archived-session ownership. - -The first endurance harness under -`.epiphany-run/idle-endurance-16c4b19f` is preserved as contaminated harness -evidence: launching Self as a shell background job inherited the shell's -non-default SIGINT disposition, so `ctrlc::try_set_handler` correctly refused -to steal it. This was not a source regression. The corrected direct-PID run in -`.epiphany-run/idle-endurance2-16c4b19f` completed 900 one-second Heartbeat -pulses and then direct-PID SIGTERM closure: Heartbeat and Self both exited zero, -Self's final projection was braked with shutdown requested, and active c005 -remained untouched. Across 984 seconds and 143 comparable Heartbeat samples, -RSS stayed 27.79--28.54 MiB; first/last-quarter averages differed by 0.06 MiB. -Across 991 seconds and 144 Self samples, RSS stayed 26.90--27.73 MiB; -first/last-quarter averages differed by 0.057 MiB. The aggregate copied state -oscillated between 7,330,870 and 7,344,497 bytes and returned to 7,332,629; -artifact payload stayed at 13,175 bytes in one pulse directory. This is useful -bounded active-marker/braked-Self physiology, not an idle cognition claim: the -copied Heartbeat store retained a stale coordinator participant marked running. - -A genuine idle control in `.epiphany-run/idle-control-16c4b19f` is complete. -Exact packaged `epiphany-verse-query` engaged the canonical typed -`epiphany/swarm-brake` under runtime `epiphany-starfire-linux` in both root and -Eyes local-Verse stores. Heartbeat completed 900 one-second refused pulses and -exited zero; the monitor then sent direct-PID SIGTERM to Self, which also exited -zero with shutdown requested. Across 139 comparable Heartbeat samples RSS was -27.77--28.52 MiB and first/last-quarter averages changed by 0.0068 MiB. Across -141 Self samples RSS was 26.97--27.73 MiB and the quarter delta was 0.0423 MiB. -Aggregate copied state stayed exactly 7,332,259 bytes and artifact payload -stayed zero. This is the accepted no-cognition baseline. Active c005 remained -untouched. - -The bounded active-cognition endurance pass has an authority map; do not -replace it with a synthetic busy fixture. Resident Self owns consumption of one -real Heartbeat grant, exact coordinator-child identity, fulfillment, terminal -receipt, cooldown, and shutdown. Heartbeat owns typed scheduling. The selected -candidate is the copied unresolved `admitted-model-direction-consideration` -request already seen minting a grant in the first physiology run; its production -route launches proposal-only Imagination cognition through the exact packaged -coordinator/model runtime. Docker stats, process counts, and operator-safe -projections are evidence only. The monitor may stop the isolated containers -after terminal proof and a measured cooldown interval; it may not write runtime -authority, inject a fake child, create retry pressure, accept a worker result, -or weaken any consequence gate. After the idle control closes, copy its body, -inspect the pending grant through packaged projections, release the canonical -brake in both local-Verse namespaces, and use a long enough turn timeout plus -cooldown to observe launch, active memory peak, typed completion, and return to -plateau. Acceptance requires exact coordinator/resident fulfillment receipts, -the typed Imagination result path, no external consequence, bounded stores and -artifacts, and clean direct-PID shutdown. If the request or grant is absent, -resolved, or mismatched, stop and choose a new request through its production -typed owner; do not manufacture endurance theater. - -Source inspection before active endurance found a continuity fault in the -resident closure path. A zero-exit bounded coordinator can publish its exact -coordinator receipt before a detached typed worker result appears; the old -cycle acknowledged the grant immediately and could permanently consume its -pressure if the worker later failed. Resident Self now keeps the active lease -and projects `awaiting-fulfillment` until the runtime-owned worker result and -exact typed companion prove terminal cognition. Proposal Modeling requires its -exact echoed request; admitted model-direction and Imagination consideration -also validate and compare their persisted typed result/candidate. Brake, -shutdown, and timeout cancel and requeue the exact pressure once through the -existing CAS. The raw completion primitive is private to this settling seam. -Imagination candidates must not predate their request. Twenty-two resident -tests, eight swarm binary tests, and eight Imagination consideration tests pass, -including exited-zero pending-to-fulfilled closure and exact-once shutdown -requeue. This cut is not packaged yet. Commit and publish it, package the exact -source with the persistent Starfire cache, authenticate all 24 binaries and -witness, then use only that release for active cognition endurance. - -Commit `30a63d63` packaged after a failed-closed construction-cache repair. -The clone initially lacked declared submodules; after exact initialization the -constructor found the known stale -`source-fb4097c8f489c830678f32a39e818cf462bff5c1fe853bc12d106184c9bfd571` -worktree whose Git common-dir named a deleted clone. Only that verified 57 MiB -source directory was removed; Cargo home and target caches survived. The same -container then completed in 8m26s. Exact release is -`sha256-a1e8a0985573f7bacf5316c62080ed4bfb8b00c7214331e0baf775d24a7a50a4`; -witness is -`sha256-473482113ac16e6656e2cb02582ee5696818b3255a7184960e8839aa291bf3b9`. -Independent packaged inspection accepted exact source and all 24 Linux ELF -binaries with zero warnings. - -The first real active-cognition attempt is preserved under -`.epiphany-run/active-cognition-30a63d63`. Packaged publication into the copied -Verse and both canonical brake releases succeeded. Heartbeat moved from -braked to `active-coordinator-turn`, but Self failed before preparation with -`resident typed request escaped its runtime or thread authority`; no worker or -external consequence launched. A quarantined read-only typed-state diagnostic -proved the request was valid, unresolved, and owned by runtime -`epiphany-starfire-linux-eyes-tools` on thread `linux-eyes-tools-c005`, while -the policy's `release_runtime_id` was `epiphany-starfire-linux`. The code had -collapsed binary-publication identity and cognitive-store identity. Both -brakes were re-engaged. Self exited 1; the manually stopped Heartbeat required -kill after its 15-second stop window and exited 137, so this run is failed -evidence, not endurance acceptance. - -The source cut now loads the mounted runtime store's immutable -`EpiphanyRuntimeIdentity`; that one owner supplies typed request validation, -plain-work thread identity, and the coordinator's `--runtime-id`. Release -runtime identity remains binary-authentication authority only. Persona feedback -target identity remains crossing-owned rather than being mass-renamed. The -diagnostic error now names safe request/kind/runtime identities, a negative test -proves a request from a foreign runtime still fails closed, and differing-ID -tests require both typed and plain prepared argv to name the cognitive runtime. -Twenty-four resident and eight swarm binary tests pass. Commit, package, -authenticate, then rerun from a fresh copy of the accepted idle baseline; do -not reuse the failed active body. - -Resident lifecycle retention is now implemented in source. Resident Self's -serve/once owner invokes a configurable `--retained-closed-lifecycles` bound -(default 256). Only Heartbeat-consumed terminal lifecycles whose pressure still -binds the consumed grant and which have no prepared/active lease are eligible. -The exact pressure/grant/ack/claim envelopes are deleted in the same -snapshot-fenced CultCache write that replaces the single retention head. The -head carries only cumulative counts and a chained digest; scheduling readers do -not consume it. Requeued brake/shutdown/failure pressure remains live. - -CultCache commit `fecc17c` on -`codex/resident-retention-compaction` adds the missing single-file atomic -replace-and-delete primitive and its stale-snapshot refusal proof. Twenty -resident Self tests and six swarm binary tests pass, including negative proof -that retention cannot create pending pressure/grants/acks or resurrect state. -Package and copied-state proof remain before this slice is accepted. - -Exact `ed15f83a` packaged in 7m26s after one failed-closed cache repair. The -first attempt found a stale cached source worktree whose `git-common-dir` -pointed at a deleted prior clone. Only that exact -`source-fb4097c8f489c830678f32a39e818cf462bff5c1fe853bc12d106184c9bfd571` -directory was removed; Cargo home and target caches were preserved. The -replacement package produced 24 binaries, release -`sha256-4a4be03688eab1d1f7c13ac0057f0664c4658cab88471a0eac451a1d4607b85d`, -and witness -`sha256-f163170174f022c124cc2f94d195639d02f65b79bac229af3efb8333176673c4`. -Independent packaged inspection accepted exact source, inventory, witness, and -private-state exclusion without warnings. - -Receipts are in `.epiphany-run/resident-retention-ed15f83a/`. Under an engaged -copied-state brake, the exact packaged Self compacted a portable fixture with -two closed lifecycles and one requeued control. The head is revision 1, -`retired_lifecycle_count=2`, `retired_envelope_count=6`, and chained digest -`sha256:69a2c5971430846590fe20ba32a1a9299726a51c997b9e9c07ec044ebbff34a6`. -The requeued control plus one independently ingested pending typed pressure -survived; grants and acknowledgements are empty. A second exact packaged pass -left the head unchanged. Active c005 remained running and untouched. - -Resident lifecycle retention is accepted. Next map coordinator receipt and -semantic/runtime history references before choosing the next compaction owner. - -The next owner map is now source-grounded. c005's copied runtime store has 22 -coordinator receipts, 20 jobs/results, 7 sessions, 482 events, and roughly 2.9 -MiB of duplicated native/OpenAI model requests. Do not compact this as one -family. Resident Self is the only live authority reader of coordinator run -receipts: after child exit zero it requires exact thread plus launch digest and -then validates the full launch contract. CultMesh Hands/review mirrors carry -the receipt ID but do not resolve it back into runtime authority. - -The bounded next slice is coordinator receipts only: runtime owns one digest -accumulator, preserves a configurable newest window plus explicit cross-store -IDs, and always preserves the newest receipt across the child-exit/ack seam. -The accumulator must not enumerate as a receipt or satisfy resident completion. -Session/job/event/model/tool retention remains forbidden until typed archived -session ownership closes tool follow-up, review, recovery, and accepted-frontier -references. - -The source implementation is accepted. Runtime owns a -typed cumulative count/digest head and exact receipt deletion behind one -full-snapshot fence. Resident Self invokes it after each cycle, before resident -lifecycle retirement, with a default-256 window and explicit preservation of -every pending terminal acknowledgement plus `last_coordinator_receipt_id`. -Even a configured zero window retains the newest receipt. The head has a -distinct CultCache type and cannot enumerate as `EpiphanyCoordinatorRunReceipt`. -Retention refuses to run while active-turn or prepared-launch authority exists, -so a child cannot write its terminal receipt during the pre-exit observation -window and have a small retention window retire it before completion scanning. -CultCache `9cae2779` supplies the same atomic replace/delete primitive to the -production non-owning redb handle; its concurrent-insert refusal test passes. -Twenty resident tests, seven swarm tests, and two coordinator-retention tests -pass. Exact `16c4b19f` produced warning-free 24-binary release -`sha256-6cd1907a87d37cd4517e3f1d3541ecee6595480c21401f977f51f63e929a8ef8` -with witness -`sha256-c9f4f8ba962bd97674c5e178a67a881b592af5833048029cd11805604bd6c17e`. -The first package attempt failed closed on the known stale cached git worktree; -only exact corrupted cache directory -`source-fb4097c8f489c830678f32a39e818cf462bff5c1fe853bc12d106184c9bfd571` -was removed, preserving Cargo home and target. The replacement completed in -9m16s and independently inspected as exact source, 24 binaries, no warnings. - -Receipts `.epiphany-run/coordinator-retention-16c4b19f` prove packaged behavior -under copied engaged-brake state. With a window of one, 21 old receipts retired; -the newest receipt and a deliberately old receipt named by both resident state -and a pending acknowledgement survived. The revision-1 head digest is -`sha256:63587221d745315af81c705824d16313d2f748b6ff9840a2b4152127a6758fbd`. -All 720 unrelated runtime envelopes retained digest -`sha256:c21a12653ce1bf0e64342c6fcbf98d006aeb8fa707de69527886db20e4c20e1c`. -Resident authority counts were unchanged, active/prepared authority remained -absent, and exact replay did not advance the head or create work. Active c005 -remained running and untouched. Coordinator receipt retention is accepted. -Next settle supervisor log ownership and packaged Heartbeat retention, then run -the measured idle/active endurance plateau. - -## Active cognition continuity fault and repaired ownership (2026-08-09) - -Exact `e09104a7` produced warning-free 24-binary release -`sha256-40d4971a3b7ecf4debf558621b80c6384c6c1a155971e42aecf44bf05d13e418` -with witness -`sha256-5f68e73e0b9ad2dff7e7cfa912455bd7e27f1a653c2a2eecd8bf5a012f146c68`. -Receipts are under `.epiphany-run/active-cognition2-e09104a7`. On a fresh copy -of the accepted idle body, exact Heartbeat launched the valid Eyes cognitive -runtime/thread. Self remained `awaiting-fulfillment` after coordinator exit, -accepted the exact typed Imagination result, wrote one terminal acknowledgement, -and Heartbeat consumed it. This live causal fulfillment seam is accepted. - -The 900-pulse run then exposed two coupled continuity faults. Completion cleared -the active lease without persisting the configured 180-second cooldown, leaving -`nextEligibleAtMillis=0`. Separately, grant issuance checked only unconsumed -grants. Once preparation marked the first grant consumed, later pressure could -receive another grant under the same still-running Heartbeat schedule/action. -The first acknowledgement then closed that Heartbeat turn while Self retained -the companion grant. Three cognitive turns ran instead of the intended single -turn plus cooldown. Final Heartbeat and Self exits were both zero, but this body -is rejected as bounded-turn/endurance proof. The detached sampler also died -mid-run and was restarted append-only; the visible sampling gap is preserved. - -Pushed commit `90648073` moves both decisions to their proper owners. Terminal -completion persists `next_eligible_at_millis` in the same CAS as lease closure -and acknowledgement publication. Heartbeat grant issuance refuses prepared or -active Self authority and advances the singleton resident-state revision in the -same pressure-to-grant CAS, so disjoint pressures cannot share a Heartbeat turn. -Twenty-four resident tests and eight swarm binary tests pass. Package exact -`90648073`, authenticate it, then replay from another fresh accepted-idle copy. -Require exactly one grant per Heartbeat turn, later pressure pending through the -persisted cooldown (including restart), typed fulfillment once, bounded return -to plateau, and clean zero exits. Active c005 remains untouched. - -Pre-package source inspection caught one surviving obsolete path: production -`cycle()` called `prepare_resident_self_launch` without reading the persisted -deadline, and preparation itself did not enforce it. The in-flight de2e8ad5 -package was stopped as invalid source; its build logs are preserved under -`.epiphany-run/linux-package-de2e8ad5/`. Pushed `ee05d9bb` moves the read into -the shared preparation primitive. A fresh post-completion call with a committed -later grant now refuses at deadline minus one and prepares exactly at the -deadline. Package latest source containing both `90648073` and `ee05d9bb`; -never resume or publish the stopped de2e8ad5 build. - -Exact `d303dd1f` then packaged as warning-free 24-binary release -`sha256-8e55c6f76dd2cf6ad93393ea99ed98a871370e68f9fe59ae234f5e494481c67d` -with witness -`sha256-1834a1f7717d6d12510f3747c5d2a758572e7267d0b766be5c1b0fa0130300e3`. -Receipts are under `.epiphany-run/active-cognition3-d303dd1f`. Exact typed -fulfillment persisted `nextEligibleAtMillis=1786305955374`. Self stopped zero -123 seconds before that deadline, restarted against the same resident store, -and remained sleeping with the exact deadline through expiry. Cooldown ownership -and restart refusal are accepted. - -The same run exposed the remaining cardinality fault. Once completion removed -prepared/active Self authority, repeated pulses of the still-running Heartbeat -schedule/action could issue again because the grant fence remembered only -unconsumed grants, not that this turn had already spent its grant. Work launched -again under `epiphany-active-cognition3-d303dd1f.serve-000131` / -`heartbeat.coordinator.work`. The copied run was stopped and rejected; immutable -logs and `run-invalidated.txt` preserve the intervention. - -The source cut now makes the persisted grant set the lifetime fence: if any -grant already names the requesting schedule/action, issuance returns none -regardless of consumption, resident idleness, cooldown expiry, cancellation, or -later pressure. Cancellation retry moves to a different Heartbeat turn; the old -test that explicitly blessed same-turn retry was corrected. Twenty-four resident, -eight swarm, and eleven heartbeat-state tests pass. Commit and push this cut, -package the exact commit, and replay from a fresh idle copy. Do not reuse the -invalid d303 body as bounded-turn evidence. - -Exact `c77824ef` packaged as warning-free 24-binary release -`sha256-e0b7c5cf54c4fb62929d91326c4604e8ad486c59411d6b2509de9182e7a83482` -with witness -`sha256-f923a10c4a96b4301a952c3f874a913535f3165fee531034bbce077811a5629b`. -The fresh copied body under `.epiphany-run/active-cognition4-c77824ef` -matched all 7,668 accepted-idle files. One exact grant completed and persisted -`nextEligibleAtMillis=1786307607233`; Self restarted zero and slept through the -deadline. Heartbeat never issued another grant after the original pulse-48 -grant, so schedule/action issuance cardinality is accepted. - -After expiry, Self nevertheless launched again. The typed diagnostic proved the -active lease named the exact already-completed pulse-48 grant, not another -Heartbeat grant. This run is rejected and was stopped with receipts. The first -repair treated `ResidentSelfTerminalAck` as grant death instead of the mutable -`consumed_at_millis` marker. Exact replay disproved that ownership cut. - -Exact `61d06140` packaged as warning-free 24-binary release -`sha256-07d63fb815aa2298b95f240d856e912ca41ed4dc70ebe17ed559fc29766b4a71` -with witness -`sha256-06cd8373ca37c29e0123298484a67b6346b4b8ec0b8c93cd959237b3d8b7787a`. -The fresh 7,668-file copied body under -`.epiphany-run/active-cognition5-61d06140` completed one typed turn, persisted -`nextEligibleAtMillis=1786308887955`, restarted Self with exit zero, and slept -through the deadline. Heartbeat issued no second grant. After expiry Self again -prepared the original grant. - -Typed inspection found no success acknowledgement for that grant and no -resident lifecycle-retention head. Singleton `ResidentSelfState` still retained -the completed closure and cooldown; stopping the rejected run later wrote the -expected shutdown-cancellation acknowledgement. The acknowledgement-only fence -was therefore built on separately retained evidence, not on the grant whose -launchability it tried to decide. - -Each `ResidentSelfHeartbeatGrant` now owns its own terminality. Completion and -cancellation write its terminal timestamp and status in the same CAS that clears -the exact active lease; cancellation also requeues the pressure in that CAS. -Pending selection and Heartbeat issuance consult the grant-owned terminal fact. -`ResidentSelfTerminalAck` is Heartbeat-facing notification and provenance, not -launch authority. The focused regression deletes the acknowledgement and clears -the grant's consumed marker, then proves the terminal grant remains dead while -later pressure may receive a new grant from a different Heartbeat turn. -Twenty-four resident, eight swarm, and eleven heartbeat-state tests pass. -Package and replay the exact committed source from a fresh accepted-idle copy; -do not accept c778 or 61d as bounded endurance evidence. - -Exact `a987d2f7` packaged as warning-free 24-binary release -`sha256-fa7476e703c807c1ec7fdf5a099e0ac36a34ff8c01e2b404a4aade1a2cf3b6d0` -with witness -`sha256-515c9caa49fb90585834520f4e8f6fdc1704145e1a0cd7b695be09ad93d14e14`. -The active6 body under `.epiphany-run/active-cognition6-a987d2f7` copied 7,667 -state/workspace/crossing/artifact files plus the machine identity from the -accepted idle control with zero hash differences, then published only that -exact release. - -The first typed turn completed at resident revision 9. Self stopped exit zero -and restarted before `nextEligibleAtMillis=1786311170229`, then slept through -the deadline. At `1786311162775` an isolated snapshot-fenced diagnostic deleted -the exact terminal acknowledgement and cleared only `consumed_at_millis`; the -v1 grant retained terminal `planned` at `1786310990229`. After expiry that grant -remained dead. A later proposal used a distinct grant from active6 pulse 77. -That grant terminalized independently, and completion of another later grant -still did not change or resurrect the corrupted original. Receipts -`corruption-receipt.txt`, `post-expiry-inspection.txt`, -`post-second-completion-inspection.txt`, and `final-inspection.txt` bind the -exact identities. - -Heartbeat completed 900 pulses and exited zero; the detached monitor stopped -Self with exit zero. Heartbeat, Self, and monitor stderr are empty. No tracked -workspace path changed. Pulse artifacts ended at three retained directories. -The final 40 samples are byte-flat: total state 13,012,660; runtime 9,225,193; -resident 22,984; Heartbeat 13,200; artifacts 298,663. Self rested at 31.92 MiB -and Heartbeat at 27.81 MiB before stop. Exact-grant terminality and bounded -active endurance are accepted. Active c005 was untouched. - -Commit `cc566a3c` cuts the typed-fulfillment authentication split. Runtime spine -now owns one typed request verifier for proposal Modeling, Imagination -consideration, and admitted model-direction consideration. It replays the exact -immutable result-admission path and then checks the persisted typed companion; -proposal Modeling additionally uses one shared immutable proposal/selection/ -launch/patch validator from both delayed fulfillment and Mind admission. -Resident Self only maps exact grant provenance to that typed request and consumes -Pending/Fulfilled/error. Echo-only rows, substituted launch bindings, item -errors, missing companions, and duplicate terminal claimants cannot complete a -grant. - -Focused proof is green: 24 resident tests, 8 `epiphany-swarm` tests, 11 -Heartbeat-state tests, and the new hostile proposal verifier test. The resident -cycle proof now exits the coordinator zero, remains `awaiting-fulfillment`, -admits an exact launch-bound model-direction result through runtime spine, and -closes once. The broader runtime-spine sweep exposed two stale fixture opinions; -commit `70683d6b` aligns them with live ownership. An existing Modeling launch -already claims scheduling authority and cannot produce a duplicate resident -grant. Proposed/Blocked frontier output stops at Mind admission, while the route -layer still refuses the resulting unadmitted state. All 50 runtime-spine tests -now pass alongside the focused suites. Package exact `70683d6b`, then prove the -same pending-to-authenticated-fulfilled transition on copied state. Active c005 -remains untouched. - -Exact `c1b461b2` then packaged as warning-free 24-binary release -`sha256-4bb7013c9d423cc8fd58be7300babe2dc1658cbcf952a7c1d9c5e0717dcd983a` -with witness -`sha256-3d2a6c9f2453c3085bb3825271069ac3451863f274bb606954cc3efd0c09edba`. -The first packaging preflight correctly refused absent submodules. A retry -exposed one stale persistent source-cache worktree whose clone volume no longer -existed; that exact cache directory was inspected, removed, and the single real -build completed in 8m49s. The accepted release contains 24 ELF x86-64 binaries, -has no build warnings, and inspects against the exact source and witness. - -The copied-state run under `.epiphany-run/fulfillment-live-c1b461b2` launched -the pending autonomous proposal Modeling grant. Its coordinator exited zero and -resident Self remained on the same lease as `awaiting-fulfillment`, proving the -new asynchronous state transition. The exact genuine worker result -`result-worker-a0be7d08-3c2b-4736-99ae-fffb72628911` was not accepted. Delayed -fulfillment re-entered the autonomous proposal validator, which required the -current external Body-status file and required every Imagination-origin proposal -to route back to Imagination. The live result coherently produced one active, -proposal-citing Eyes frontier for receipt-body research. Self therefore -terminalized the grant as `unfulfilled`. This run is preserved falsification -evidence, not a successful fulfillment proof. Self later stopped on SIGTERM in -1.686s with exit zero and final `braked`; active c005 was untouched. - -Commit `c9738fdb` repairs the authority split. Immutable autonomous origin, -direction, launch, payload, result, and frontier provenance now own delayed -fulfillment. Current external Body authentication remains a separate Mind -admission requirement. An autonomous result may route to Eyes for evidence or -back to Imagination, but direct Hands and pre-adopted plans remain forbidden. -The regression deletes the fixture's current Body-status file and still proves -typed fulfillment; the autonomous bridge accepts an Eyes continuation and -continues to reject direct Hands. All 50 runtime-spine and 24 resident tests -pass. Package exact `c9738fdb` and replay the pending-to-fulfilled transition -from a fresh copied state; do not rehabilitate the rejected c1b run. - -Exact `6dd9b132` packaged in 8m47s as warning-free 24-binary release -`sha256-e9380f98b000e216705218c96f2925976558fff63113d5d003aed443ba80aadd` -with witness -`sha256-271f062be9b77d9a49d7aa26884c64db65c42919d30d8fecf650c7cb7890c86c`. -The Linux-native source volume was required because a Windows bind mount made -Linux Git report line-ending changes across the tracked tree; both preflight -refusals are preserved and no build began under either. The accepted package -contains 24 x86-64 ELF binaries and no warning/error log matches. - -The fresh copied body under `.epiphany-run/fulfillment-live-6dd9b132` contains -7,678 files and matched the Active6 machine ID plus six authority/store hashes -exactly before publishing only the new release. The exact pending autonomous -proposal grant launched once. Coordinator exit left Self on the same lease as -`awaiting-fulfillment` while the detached Modeling worker continued. Runtime -then admitted `result-worker-cae0cad1-188e-46fa-832c-7cb0676422dd` with typed -`checkpoint-update-needed` and one active proposal-citing Eyes frontier. Self -completed at revision 21 with exactly one result, one `planned` terminal -acknowledgement, terminal `planned` on the exact grant, and persisted -`nextEligibleAtMillis=1786318158509`. Continued serve cycles did not duplicate -result or acknowledgement. The copied workspace has zero tracked changes. -SIGTERM completed in 577ms with exit zero and final `braked`. Runtime-owned -asynchronous typed fulfillment is accepted; active c005 was untouched. - -The next pass is broad semantic/runtime retention. Map session/job/event, -model-request/result/stream-event, and tool-intent/receipt ownership and -cross-store liveness before editing. No age-only deletion and no broad -compaction are authorized until one typed archived-session owner can prove a -fully closed, unreferenced generation cannot resurrect or erase work. - -The retention audit found the missing ownership edge: runtime sessions own -jobs/events, but native/OpenAI model rows had only request/conversation IDs and -tools were linked only optionally. Semantic Mind/consequence documents in the -same store are not session exhaust. The current cut adds typed -`EpiphanyRuntimeModelExecutionBinding` plus one runtime-spine CAS that publishes -session, job, opened event, binding, native request, and provider request -atomically before transport. Collision and mismatched provider pairs leave no -partial rows. Core hostile membership, CultNet Hello/catalog, and all 15 OpenAI -runtime library tests pass. No archive deletion is authorized yet. Next, give -model-derived and direct tool intents explicit execution ownership atomically; -then map retained semantic references before building the archived-session -tombstone. - -Tool execution ownership is now cut too. Runtime spine owns -`EpiphanyRuntimeToolExecutionBinding`; intent plus owner edge publish atomically, -model-derived intents must inherit the exact model execution, and direct -intents require explicit session/job ownership. The tool runtime refuses -unbound intents before execution. Terminal receipts are immutable and CAS -fenced against the exact binding and intent, so a hostile/duplicate receipt -cannot supply closure. Core hostile tests, all 15 OpenAI tests, and all 10 tool -runtime tests pass warning-free. The next pass is source-grounded retained -reference classification across semantic, frontier, Hands/Soul, Persona, -memory, resident, and coordinator readers before any archived-session deletion -is implemented. - -Retained-reference inspection found the archive unit itself was false: worker -model sessions were role-long and remained open for later workers. They now -derive from the exact outer worker job ID, so one session owns that worker's -initial and tool-followup model jobs only. Success closes it after typed outer -result admission. Loop-stall and round-limit paths terminalize the exact -unexecuted tool intents, fail the outer job, and close the same inner session. -Six OpenAI CLI and 15 library tests pass, including terminal receipt/session -assertions. The next cut is the narrow archived model-session tombstone; it -must retain exact IDs and delete only inner execution envelopes, never outer -worker or semantic authority. - -## Narrow model-generation archive — source-proven 2026-08-10 - -Runtime spine now owns `EpiphanyArchivedRuntimeSession`. Archive admission is -deliberately narrow: the session is Completed; every member job is an -`openai-model-adapter` job with exactly one model-execution binding and terminal -job result; native and OpenAI requests, streams, and receipts agree and are -terminal; and every bound tool intent has one authenticated terminal receipt. -Outer worker launches/results, coordinator receipts, semantic/Mind/consequence -documents, unknown rows, and unrelated runtime envelopes are not members. - -One full-snapshot-fenced replacement writes a tombstone containing the exact -session/job/result/request/intent IDs, terminal counts, retired-family counts, -and chained envelope digest while deleting only that inner execution family. -Those retained IDs are the permanent reuse barrier. A stale snapshot refuses; -an unreceipted tool refuses; exact replay is idempotent; and unrelated envelopes -remain byte-identical. Resident Self calls the bounded owner only while neither -active nor prepared launch authority exists. The configurable default window -is 256 and at least the newest completed model generation always survives. - -The exact archive test and two-generation retention-window test pass, as do all -eight `epiphany-swarm` tests and `cargo check`. The schema and CultNet catalog -parse. This cut is not yet committed, packaged, or exercised on copied live -state. Next commit/push it, package only that exact commit with Starfire's -persistent Linux cache, then prove tombstone non-resurrection and byte identity -on copied state. Active c005 remains untouchable. Yggdrasil never builds. - -Commit `c137e16b` contains that cut and is pushed. Exact packaging completed in -7m17s with 24 binaries, release -`sha256-44cdf05f7f2e4830702d211006914e9ac27875f1340abd74b72756e262beddce`, -and witness -`sha256-c7ecb23021a49d63f2893053c5653146688c0884f3eac0c6808bb29b6489abdf`, -but the candidate is rejected: production compilation emitted one unused -`tool_invocation_receipt_key` import warning from the tool-runtime binary. Logs -are under `.epiphany-run/linux-package-c137e16b`. - -The import was used only by binary tests and now lives inside `cfg(test)`. -Production `cargo check` and all four tool-runtime binary tests pass without -warnings. Commit/push this follow-up and package that new exact source; do not -accept or publish the warning-bearing c137 package as shakedown evidence. - -## Packaged model-generation retention accepted — 2026-08-10 - -Follow-up `cce2b8ac` is pushed. Its warm Starfire package took 20.70s, emitted -zero warnings, contained 24 binaries, and authenticated as release -`sha256-1f29f33c495e8ba79ce8e23c1ac923c4ffcd5d86c97632a17d44566669de481e` -with witness -`sha256-25e48f9c79c51cd9853e826e2f9dfdb3b2570006fd37138fd36ac1555bc075e7`. -Package and inspect receipts are under `.epiphany-run/linux-package-cce2b8ac`. - -Copied live proof is under `.epiphany-run/model-session-retention-cce2b8ac`. -Two exact packaged direct-OpenAI calls created unique model sessions, jobs, -bindings, native/provider terminal streams and receipts; both returned `awake`, -passed, and were closed by the packaged runtime spine. With no active or -prepared resident lease and the copied brake engaged, packaged Self ran once -with `--retained-completed-model-sessions 1`. The older session became one -`epiphany.runtime.archived_session.v0` tombstone covering 29 exact envelopes -with chained digest -`sha256:fc3658898d383333edff411f64999af7890cdeaf8fdce737589bc5667f65db33`. -The newer session/request survived; pending tool count stayed zero; recreation -of the old session exited 1 with `was retired by archive`; and exact Self replay -left runtime SHA-256 -`15e25ba3c21bed45fe48cb30034959de87b3f0cb973d7c80e4a7808dc91affb5` -unchanged. - -A proof-local read-only CultCache comparator found all 1,427 envelopes from the -copied pre-run store still present. Only the model/OpenAI adapter status rows -changed, as owned consequences of the two genuine calls; zero pre-existing -authority envelopes changed. Active c005 was never mounted or disturbed. - -The proof also exposed the next contract wound. `epiphany-model-runtime -model-turn` claims JSON request ingestion and the published schema describes an -object, but `serde_json::from_str::` inherits the -DatabaseEntry positional-array representation. Two object-shaped requests -failed before store mutation; only the native CultCache array shape passed. -Repair this xenos JSON boundary with an explicit schema-shaped ingress type and -typed conversion. Do not change CultCache persistence to accommodate JSON. - -## Model-turn JSON boundary implemented — 2026-08-10 - -`epiphany-model-runtime model-turn` now parses the two published object-shaped -contracts through explicit boundary DTOs and dispatches by exact `schema_id`. -The boundary accepts only the fields and input variants published by -`epiphany.model_request.v0` and `epiphany.openai_model_request.v0`, then converts -them into the existing typed requests. Positional CultCache arrays, unknown -fields, malformed variants, and unpublished `ToolCall` cargo refuse before the -runtime path. DatabaseEntry serialization remains solely the persistence -authority. - -All nine model-runtime binary tests pass, including published native/provider -object acceptance and the negative boundary cases. Production `cargo check` -also passes warning-free. The source is not accepted until its exact pushed -commit is packaged from Starfire's warm cache and a copied-live run proves one -published object completes while the old positional array cannot mutate state. -Active c005 remains outside this rite; Yggdrasil never builds. - -## Model-turn JSON boundary accepted live — 2026-08-10 - -Exact pushed source `eea15e82` produced a warning-free 24-binary release -`sha256-6a45bef43ef9f4ecbdc2ba69b8dfee9edf9bb085ce0d482c1ad1649b35464186` -with witness -`sha256-088393f4eb9784819250f6a6b44d73bc92c9d889c4eaa2a0a13868c6c71f7cda`. -Construction and inspection receipts are under -`.epiphany-run/linux-package-eea15e82`. - -The persistent package source was refreshed from an immutable Git bundle after -the Windows bind-mounted object store lost a temporary pack. Packaging then -found a 48,104,292-byte cached source worktree whose `.git` pointed at a vanished -source repo. That exact cache entry was removed under -`.epiphany-run/interventions/package-cache-stale-worktree-20260810T0145Z`; -Cargo home and graph artifacts remained. The reconstructed package completed in -8m43s. Both preflight refusals and the contaminated old-source launch are -preserved beside the accepted logs. - -Copied-live receipts are under `.epiphany-run/model-json-ingress-eea15e82`. -The exact packaged binary accepted one published native JSON object and completed -it through `epiphany_direct_responses_http` in 5.9 seconds: pass verdict, two -events, zero tools, and the exact typed request persisted. Its copied session was -then closed. The old positional CultCache array exited 1 with `model-turn request -must be an object with string schema_id`, created no request, and left runtime -SHA-256 -`944494eeb6416e3123a2cb65e00e9e130c130f7c1ec8988f810bb48d55dc83da` -unchanged. JSON ingress is accepted; CultCache remains persistence-only. - -Next map semantic and conversation-wide history retention before editing. Name -the producer, live-authority preservation set, closure predicate, retirement -evidence, and negative non-resurrection proof for each family. Active c005 stays -untouched and Yggdrasil never builds. - -## Next retention owners mapped — 2026-08-10 - -Semantic projection lifecycle and Persona conversation lifecycle are distinct -cuts. For semantic projection, the canonical source store owns logical history: -preserve the authenticated current obligation, singleton scope claim, current -claim authority, running attempt, and exact readiness chain; retire only older -source generations and their terminal/consumed lifecycle documents under a full -snapshot fence. A typed per-scope head is evidence only. Physical Qdrant epoch -garbage is a second semantic-executor action bound to exact retired epoch -identity; backend failure may leak space but cannot change readiness. - -Persona conversation retirement is cross-store and comes later. Heartbeat owns -terminal scheduling, runtime owns stage/effect/execution evidence, and Bifrost -owns signed delivery audit. A durable archived-turn identity barrier is required -before runtime details can retire, otherwise the model executor can recreate a -previously consequential turn. Failed/unknown delivery evidence must continue -to prevent automatic retry. - -Implement semantic logical lifecycle retention first. Refuse while the current -claim/attempt is running, preserve every current-chain reference explicitly, -replace only exact older terminal generations plus one typed head under a full -snapshot fence, and prove the head cannot open readiness or claim authority. - -## Semantic logical lifecycle retention implemented — 2026-08-10 - -The canonical semantic source store now owns bounded logical lifecycle history. -After each projector pulse, the production daemon retains the newest 256 source -generations by default. The cut preserves the exact current obligation, the -singleton scope claim and authenticated claim authority, and every envelope in -the current readiness family. It refuses retirement while current authority is -running or when a same-scope future/non-stale obligation appears. Only older -closed obligations and their terminal attempts, valid receipts, consumed -executor grants, and recovery authorizations can retire. - -One typed per-scope retention head carries cumulative type/status counts and a -chained digest. The head is evidence only. Head replacement and exact lifecycle -deletion share the source store's full-snapshot fence; unknown rows are outside -the deletion set. Retention faults degrade the projector heartbeat but cannot -redefine semantic completion or suppress health publication. - -Four focused tests pass: current ready-chain preservation, running-current -refusal, hostile future-generation refusal even inside the recency window, and -stale-snapshot refusal with unrelated-row byte identity and stable replay. The -production semantic-projector binary checks warning-free. An ignored readiness -lookup that discarded its result was removed; exact claim, attempt, authority, -and receipt contracts remain the real owners. - -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. - -## Semantic live proof and physical cut correction — 2026-08-10 - -Exact `7e320b5d` packaged warning-free with 24 binaries as release -`sha256-0f0ff0883f1d84e07fb0485a1d5a4357036b49fad350a041c35a254a09c15441` -and witness -`sha256-96fbe50a32d915eaa23c4260b3c2734b71dc8341fc3248eff56151ae8fefcebc`. -On a pristine copy of `active-cognition6-a987d2f7` Eyes-tools state, window-one -retention retired three superseded unattempted Modeling obligations into a -revision-1 head with digest -`sha256:1cbb209d0cac9decf0715fd91faf07d1c0261805a04c0e6c0af9f3c3d7b5bb54`. -The comparator found zero missing or changed unrelated envelopes. Mind remained -byte-identical across all 20 envelopes and retained exact ready status, receipt, -hashes, generation, and 43-document count. The ordinary packaged semantic -consumer read both retained stores. Replay reported zero retention mutations; -the head remained revision 1. Receipts are under -`.epiphany-run/semantic-retention-7e320b5d`. - -The following physical audit found a cut error before final acceptance. A -digest/count head cannot tell a later Qdrant collector the exact collection, -obligation, claim, and epoch whose points are safe to delete. Deleting a failed -or succeeded attempt first would therefore strand physical garbage, especially -across crash or collection-config change. The source cut now preserves any old -obligation that has an attempt, receipt, executor grant, or recovery -authorization. Only genuinely unattempted superseded obligations compact. - -Attempted lifecycle retirement remains open until retention atomically emits a -durable physical-retirement obligation carrying the exact namespace and the -semantic executor writes a terminal deletion receipt. Backend failure may then -delay space recovery without losing retry identity or changing readiness. Four -focused tests pass after the fail-closed cut. Package that exact source and -repeat the same copied-state proof before accepting this phase. - -## Semantic unattempted retention accepted live — 2026-08-10 - -Exact pushed source `b1e8c89a` produced a warning-free 24-binary release -`sha256-3ce86fa7ce0ce15d78756d1f57b56e972d9bc37be3115b302ec567ce5e9b202e` -with witness -`sha256-fb1dd5599340a2e94600994d68661ed53820ba7fc605ac5b753f5e9632b46baf`. -Construction and inspection receipts are under -`.epiphany-run/linux-package-b1e8c89a`. - -The pristine copied-state proof under -`.epiphany-run/semantic-retention-b1e8c89a` retired exactly the same three -superseded unattempted Modeling obligations into revision-1 digest -`sha256:1cbb209d0cac9decf0715fd91faf07d1c0261805a04c0e6c0af9f3c3d7b5bb54`. -No unrelated envelope changed or disappeared. All 20 Mind envelopes retained -byte-identical digest -`sha256:910d2a8fd06030045f0e72864a80f5cb6571d66aa49a99002e2f2d0286cb388d`. -Packaged health preserved the exact ready Mind obligation, receipt, hashes, -generation 1, and 43-document count. Normal readers accepted the retention -head. Replay made zero retention mutations and left the head at revision 1. - -The accepted boundary is deliberately narrow: unattempted superseded semantic -obligations are bounded; every attempted generation remains durable. The next -cut is a physical-retirement obligation and executor receipt carrying exact -backend namespace. Active `c005` was untouched. Yggdrasil did not build. - -## Physical namespace ownership foundation — 2026-08-10 - -The physical audit found that collection identity alone was insufficient: a -historical Qdrant endpoint is also part of the address. Projector acquisition -now persists the exact configured endpoint and partition collection on each new -semantic attempt before backend I/O. Execution refuses and terminally fails a -claim when its current config differs, without touching either backend. Legacy -attempt rows remain readable with both fields empty; no migration fabricates a -physical address that was never recorded. - -Ten focused semantic authority tests pass, including exact namespace persistence -and substituted-endpoint refusal before backend I/O. The next move is the typed -physical-retirement obligation/receipt CAS and policy-bound executor. This source -foundation is not yet packaged or accepted live. - -## Typed semantic physical retirement implemented — 2026-08-10 - -Source now contains the complete typed circuit: full-snapshot authorization of -inactive old attempts, immutable exact-namespace obligations, current-policy -endpoint/collection gating before backend I/O, full five-field Qdrant scope -deletion, empty-scope verification, terminal receipts, retry preservation on -backend failure, and logical compaction only after every attempted epoch is -physically receipted. Pending obligation replay keeps its original timestamp and -identity. General Mind and runtime readers register both new evidence schemas. - -The end-to-end fake-backend test proves foreign endpoints cause zero reads or -deletes, backend failure leaves the obligation without a receipt and blocks -logical compaction, retry deletes only the exact scope, and the receipt then -permits bounded lifecycle retirement. The complete library sweep passes 644 -tests with one intentional ignored helper after three stale `.ccmp` test fixtures -were corrected to the current explicit runtime-store extension contract. - -This phase is source-complete but not yet packaged or accepted live. Next: -commit/push, produce one exact cached package, then use copied canonical state -and an isolated Qdrant body to prove physical points disappear, unrelated -namespaces remain byte/ID-identical, failure retries, ordinary semantic health -survives, and replay is inert. Active `c005` remains untouchable; Yggdrasil never -builds. - -## Semantic physical retirement accepted live — 2026-08-10 - -Exact pushed source `6bc3ec3f2493c75b6fa7f61ad3b675b10b67ab0f` -packaged warning-free in 8m11s with 24 binaries as release -`sha256-fb1bf9258a7d977fd92d6f8ee17bb540fa870477cdf1d3cea9707ec8d582d4aa` -and witness -`sha256-b42dba7296739dc48ecf0d8014a16f9d232cd723ed0292830d50879f546c0e6d`. -The exact packaged inspector authenticated source, destination, witness, and all -24 sibling binaries. Package receipts are under -`.epiphany-run/linux-package-6bc3ec3f`. - -The isolated copied-live proof under -`.epiphany-run/semantic-physical-6bc3ec3f` seeded one old failed Modeling epoch -and four Qdrant points: two in its exact five-field namespace, one with a foreign -claim epoch, and one with a foreign obligation. Exact packaged execution deleted -only the two target points. Both hostile neighbors survived. The old obligation, -attempt, grant, physical obligation, and terminal receipt then compacted into a -revision-1 head with four retired generations, eight retired envelopes, and -digest -`sha256:eb447221ee3344eb75e50cc47097c42aa6479a7afe9f3be9a87dba352f51a01b`. -All physical proof rows were absent afterward; replay reported zero retention -mutations and preserved both hostile Qdrant points. - -A second pristine copy proved failure continuity. With Qdrant stopped, exact -packaged execution reported one physical retention fault, preserved all three -old lifecycle rows plus one durable physical obligation, wrote no terminal -receipt, and refused logical compaction of that attempted epoch. After the same -Qdrant body restarted, the next exact pulse deleted only the target namespace, -wrote the receipt, and compacted the family into revision-2 digest -`sha256:113c5057dc66f6393a4548d89ad3d177e4d43cce2a4cd12bc340430f013df2c7`. -The two hostile points again survived. - -Mind remained byte-identical at -`sha256:d9d9e61af5fe3f71272754e8fa07dde2a94083fc4bc2c1cbf086d4691bf9a19e` -and exact packaged health remained ready with its original obligation, receipt, -hashes, generation 1, 43 documents, and 1024 dimensions. Modeling retained its -exact canonical obligation/hash/generation and remained failed only because the -copied proof deliberately withheld Ollama. The temporary Qdrant container was -removed after its persisted proof data was sealed. Active `c005` was untouched; -Yggdrasil did not build. -## Persona conversation retention source complete — 2026-08-10 - -Heartbeat now owns a typed Persona conversation cleanup plan and cumulative -replay frontier. The production Persona service uses that plan to retire only -fully closed `delivered`, `silence`, or `dropped` families. Runtime, Epiphany -delivery-request, and Bifrost delivery-receipt stores delete only exact planned -envelopes under full-snapshot fences and leave singleton typed cleanup receipts; -retry refuses unexplained absence. Heartbeat removes the terminal requests only -after all detail cleanup succeeds, then advances the monotonic chained-digest -frontier. Reservation rejects nonterminal work at or behind that frontier. - -Failed/unknown delivery, retained mentions, blocked conversation quarantine, -missing model or execution evidence, started/quarantined effects, pending -feedback, consent/disclosure state, Persona state, semantic memory, and -relationship memory do not qualify. Three focused tests pass, the full core -library passes 646/0 with one ignored helper, all 15 OpenAI runtime library -tests pass, and the production Persona service checks cleanly. - -Next: commit/push this source, package and inspect the exact commit on Starfire, -then prove against copied state and signed synthetic crossing fixtures that one -completed speech lifecycle retires, pending/failed/unknown/quarantined neighbors -survive, crash retry is exact, replay is inert, and the head cannot reserve or -repost the old turn. Preserve active c005. Yggdrasil never builds. - -## Persona conversation retention accepted live — 2026-08-10 - -Exact pushed source `44230a05390065f3826506619c7eaa099a0ebd88` packaged -warning-free with 24 binaries as release -`sha256-aed15bfb419c6c76ad09e1020e0c3e3d0f6dee52f5d615e18bbc61095aa76ea9` -and witness -`sha256-77d3b45e2cd48f5785f02539ba92238013f2385537a776d45514ac13e704706e`. -The copied signed fixture retired one completed speech turn and eight runtime -detail envelopes. A newer dropped turn, failed retained turn, signed unknown -quarantine, pending delivery, blocked pressure, and pending model evidence all -survived. The five store hashes and typed inspection were identical on replay; -the completed crossing request and receipt were not recreated or reposted. - -The crash boundary was forced by mounting the receipt store read-only. Runtime -and request cleanup completed, receipt replacement failed with `EBUSY`, and -Heartbeat retained both the exact cleanup plan and old terminal turn with no -retention head. Normal retry authenticated the existing local cleanup receipts, -deleted only the exact signed receipt, cleared the plan, removed the old turn, -and produced a revision-1 head. Pending and hostile neighbors remained intact. -Receipts are under `.epiphany-run/persona-retention-44230a05`; active c005 was -untouched and Yggdrasil did not build. - -Next: establish stable Starfire firewall ownership, then continue the broad -remaining organ-coordination matrix. Preserve active c005. - -## Stable Starfire firewall ownership accepted — 2026-08-10 - -Gamecult-ops exact `6ee08a4` already owns the firewall seam through -`scripts/allow-starfire-epiphany-persona-permit.ps1`; Epiphany's open status was -stale. Authoritative Starfire state contains the same exact enabled local rule -in both Windows `PersistentStore` and `ActiveStore`: inbound Public UDP 17877, -local `10.77.0.2`, remote `10.77.0.1`, interface -`wg-gamecult-starfire`. There are zero application-filter rules for changing -`epiphany-persona-discord-permit.exe` release paths. The WireGuard tunnel is -automatic and running with `10.77.0.2/24` on that interface. - -A non-elevated attempt to reconcile the rule was refused with access denied -before any mutation; exact before/after snapshots were identical. This was not -used as idempotence proof. Persistence is instead grounded by the exact -PersistentStore row, the identical active projection, the committed owning -script/runbook, and the already accepted cross-host permit proof. Receipts are -under `.epiphany-run/firewall-bffbaa45`. Active c005 was untouched. - -Next: map bounded runtime model event/session/tool history and its -non-resurrection boundary before editing. Yggdrasil never builds. - -## Coordinator runtime-session retention gap mapped — 2026-08-10 - -Existing `archive_completed_model_session` already owns the exact closed -model-adapter family, including native/provider streams and tool evidence. It -correctly refuses outer-worker and coordinator authority. The actual remaining -growth fault is upstream: `epiphany-mvp-coordinator` creates a -`coordinator-{thread_id}` runtime session and start event, then writes a -terminal coordinator receipt without ever closing the session. The store keeps -false `Active` sessions indefinitely; generic receipt retention may later -remove their only terminal evidence. - -The next cut is an atomic runtime-spine finalizer for receipt + completed -session + deterministic completion event. Completed coordinator-session -archival then owns that exact family, including its receipt. Generic receipt -retention must preserve every receipt still named by a live/completed session -and own only orphans; two deleters may not race for the same authority. Legacy -repair is permitted only from one exact matching terminal receipt, no jobs, and -the authenticated coordinator event shape. Do not weaken model-session -refusals or infer terminality from age. - -Next: implement the owner cut with hostile CAS/replay/legacy tests, then package -and prove copied-state plateau. Preserve active c005. Yggdrasil never builds. - -## Atomic coordinator terminalization implemented — 2026-08-10 - -`finalize_coordinator_run` now commits the immutable coordinator receipt, -Completed runtime session, and deterministic `session.completed` event as one -full-snapshot-fenced transaction. Exact replay is idempotent. A concurrent -unknown row, any session job, partial terminal receipt/event, or non-Active -session refuses the complete write. `epiphany-mvp-coordinator` uses this owner -and records post-terminal runtime status. - -The first attempted implementation exposed a real CultCache gap: scoped CAS -could not fence unknown identities, while the compaction primitive required a -deletion. No dummy deletion was added. CultCache exact `e1fc4c0` introduces -`replace_and_append_if_snapshot_unchanged` for snapshot, keyed, and owned-keyed -stores, with a hostile concurrent-row test. All 38 CultCache tests and the full -Epiphany core library (647 passed, one ignored) are green; the coordinator -release target checks with `coordinator-runtime` enabled. - -Next: repair only exact legacy false-Active coordinator sessions, archive the -whole completed coordinator family under one owner, and make generic receipt -retention preserve receipts still bound to runtime sessions. This source is not -yet packaged. Active c005 remains untouched; Yggdrasil never builds. - -## Coordinator session lifecycle owner implemented — 2026-08-10 - -Runtime spine now owns the rest of the native coordinator lifecycle. Before -retention, it repairs only a jobless `coordinator-{thread_id}` session that has -one exact bound terminal receipt and only authenticated `coordinator.started` -events. Ambiguous receipts, jobs, malformed events, or changed snapshots refuse -without mutation. Completed coordinator archival then replaces the exact -session, receipt, start/completion events, and their digest with one typed -archive tombstone under the same full-snapshot fence used by model-session -archival. Exact replay is inert and the archive prevents recreation. - -The deletion boundary is single-owner. Completed-session archival runs before -generic receipt retention; it receives resident cross-store liveness and will -not archive a family whose receipt remains named by Self. Generic receipt -retention independently preserves every receipt bound to any surviving runtime -session and therefore owns only orphan history. A hostile concurrent event -invalidates the archive snapshot, and unrelated runtime envelopes remain -byte-identical. - -Focused coordinator tests pass 58/58. The full core library passes 649 tests -with one intentional ignore, both release/core swarm binary suites pass 8/8, -and the coordinator release target checks with `coordinator-runtime`. Commit -`0ce5a800` contains the source cut and is pushed. It is not yet packaged or -exercised on copied live state. Active c005 was untouched. - -Next: commit and push this exact source, package it once with the persistent -Starfire cache, then prove copied-live repair, archival, non-resurrection, and -bounded idle/active session counts. Yggdrasil never builds. - -## Copied-live coordinator lifecycle falsification and corrected owner — 2026-08-10 - -Exact pushed `5a479522` packaged successfully as -`sha256-7aadee7aeb651c480a7ac82248f03329e5ebded9a64d5332169b9d5f310a6619` -with witness -`sha256-89802be96d223c60b176cd69d144e691899f12110bc7747b0e79c5e67cc389bc`, -24 binaries, no warnings, and authenticated inspection. The first changed-core -package took 8m21s; an identical warm replay took 12.13s wall with Cargo at -0.92s and reproduced the exact release and witness. - -Copied c005 state then falsified the source-complete claim. Its historical -`coordinator-linux-eyes-tools-c005` has multiple terminal receipts, so exact -repair correctly refused ambiguity without mutation. A cleaner exact copy from -the accepted b8138a6b shutdown proof repaired one legacy Active session to -Completed under the packaged binary. While creating a newer terminal session -for archival proof, a deliberate coordinator input failure left a new Active -session: coordinator startup still wrote session and start event separately, -and ordinary `?` exits bypassed the success-only finalizer. - -The corrected source moves coordinator opening into runtime spine. Session and -deterministic `coordinator.started` event now commit together under one full -snapshot fence. Existing session, event, receipt, or thread authority refuses -reuse rather than appending another start event. Once opening succeeds, every -ordinary error is converted into a failed coordinator receipt and passed -through the same atomic terminalizer before the error returns. Hard process -death remains a distinct Continuity recovery boundary; retention does not -invent a receipt from age. - -Verification is green: 59 focused coordinator tests; 17 coordinator-binary -tests including deliberate conflicting intake and exact failed terminalization; -both swarm binary suites at 8/8; and the full core library at 650 passed with -one intentional ignore. The corrected source is not yet committed or packaged. -Receipts for the falsification and first package are under -`.epiphany-run/coordinator-session-live-5a479522*` and -`.epiphany-run/linux-package-5a479522*`. Active c005 was untouched. - -Next: commit/push the corrected owner, package it exactly, then repeat the -copied-live error closure, repair, archival, replay, and plateau proof. - -## Corrected coordinator lifecycle accepted live — 2026-08-10 - -Corrected source `497df4586cd59411e51c75c245bbb2c32ac30d91` is pushed and packaged as -`sha256-3563c90961cd9404d7c0d2c12cfa5e87859960d583c3789e7bcf80a6eab2435a` -with witness -`sha256-d02d2fe59160ae83036befd345a52e5ce8704abf372c804644ee1e252e13d341`. -Inspection authenticated all 24 binaries with no warnings. The changed-core -package took 7m11s. An identical warm replay took 13.82s wall, Cargo 0.83s, -and reproduced the release and witness exactly. Persistent caching is healthy; -the remaining cold-edge cost is core-to-24-binary optimized link fan-out. - -The copied-live proof started from an exact runtime-store copy of accepted -b8138a6b evidence. The packaged coordinator deliberately failed after opening -and returned exit 1 only after emitting failed receipt -`coordinator-run-retention-proof-error-newer-failed-1786346833003`, its -completion event, and a Completed session. Runtime status then showed two -sessions with exactly one Active: the new failure was closed and only the old -legacy session remained live. - -With the copied swarm braked, packaged Self repaired the older one-receipt -legacy session and archived that exact family while retaining the newer failed -session. Post-retention runtime status was one session, zero Active, zero jobs, -zero open jobs, zero actionable Eyes/Hands frontiers, and the newer start plus -completion events. An immediate replay left runtime SHA-256 -`669f3de53ef38d06248503151bca6d7dac216f794c9e62c92af4fa994c385461` -byte-identical. A subsequent 30-second serve advanced from 7 to 33 operator -projections while preserving that exact runtime digest; memory stayed around -27.6–28.4 MiB, two processes, and SIGTERM ended at exit zero with final braked -projection. Receipts are under -`.epiphany-run/coordinator-session-live-497df458` and both exact package dirs. -Active c005 was untouched. - -Normal coordinator lifecycle ownership is accepted. The next distinct fault is -a hard process death after atomic opening but before any receipt. Continuity -must ground that repair in exact process/lease authority; age, retention, and -absence of a receipt cannot infer death. - -## Receipt-free coordinator death recovery source cut — 2026-08-10 - -The Continuity owner is now implemented but not yet packaged. Resident Self -requires its exact persisted active lease, immutable child claim, active -unterminated grant, and an independent native observation proving the exact -process incarnation exited, disappeared, or was replaced. Exact-alive, -inaccessible, and indeterminate observations refuse recovery. Runtime -Continuity then atomically replaces only the matching Active jobless -coordinator session as Completed while appending one typed death-recovery -receipt and one deterministic recovery event. A normal coordinator receipt and -a death-recovery receipt cannot coexist. Replays are exact and snapshot races -leave the Active family unchanged. - -The cut exposed and removed a deeper identity conflation. The cognitive thread -is request-owned context and must survive retries; it is not a run identity. -Ordinary coordinators retain `coordinator-{thread}` sessions, while resident -coordinator sessions are now derived from the exact launch digest. A cancelled -grant therefore terminalizes and requeues through the existing resident CAS, -then the new grant produces a distinct session incarnation on the same -cognitive thread. Archived session tombstones and terminal families still -refuse exact incarnation reuse. - -The receipt-free classifier distinguishes three crash boundaries. If the exact -process died before atomic runtime opening, the entire incarnation family must -be absent and resident cancellation may requeue without synthetic runtime -state. If a typed result is already authenticated, runtime death recovery can -terminalize the process and the original grant closes as -`recovered-fulfilled`. If a typed worker launch exists without terminal -fulfillment, the active lease remains `awaiting-fulfillment`; duplicate launch -is forbidden until orphan-worker terminality and explicit supersession have a -real owner. This last Continuity seam remains open. Retry artifact directories -are keyed by grant incarnation, not cognitive thread, preserving prior attempt -evidence byte-for-byte. - -Focused death-recovery, resident requeue/new-incarnation, and legacy retention -tests pass. Final serial verification under -`.epiphany-run/continuity-death-recovery-source` passed 653 library tests with -one intentional ignore, all 17 coordinator-binary tests, and all 8 swarm tests; -stderr is empty and the detached suite recorded exit zero. The first parallel -full-library run had exposed one real eager-fallback archive bug plus two Git -fixture flakes; the archive bug is fixed, the serial suite removes the fixture -contention, and the complete corrected source pass is green. Commit, exact -packaging, and copied-live hard-death proof remain. Active c005 remains -untouched. - -## Packaged worker terminal-failure ownership accepted — 2026-08-10 - -Source `7637b1cf0ecb12a7eacffc77a835b30046c2975b` is pushed and packaged as -`sha256-fa3a1e1528191012c051f1b431d5a5ae392c140ee6219700c041c517b347facc` -with witness -`sha256-f5c3a576cc1f740f271ee69fec1b27dc296c62b1be1cfc9fb075909337c59914`. -Authenticated inspection found 24 binaries and zero warnings. Cargo took 7m19s -and the container took 7m31s. Receipts are under -`.epiphany-run/linux-package-7637b1cf`. - -Fresh copied Linux state exercised the exact packaged model runtime. After -activation, missing model transport produced the expected typed failed worker -result and process exit zero. The same runtime transaction left the job -`Failed` and its exact claim `terminal-failure`, bound to -`result-worker-packaged-terminal-failure-job`. Resident canonical settlement -then cleared the active lease, terminalized the grant `process-failed`, emitted -one cancellation acknowledgement, and returned the pressure to pending once. -Heartbeat issued attempt two. Its distinct job and process creation token also -terminated under its own generic result authority while the first claim stayed -terminal. There was no dual live authority. Receipts are under -`.epiphany-run/worker-terminal-failure-7637b1cf`. - -Next: prove a valid typed result published before the coordinator receipt closes -the original grant exactly once without retry. Then run retention against these -terminal attempts and settled grant and require non-resurrection. Actual c006 -stays braked and stopped; Yggdrasil never builds. - -## Resident-owned fulfilled-before-receipt source cut — 2026-08-10 - -The receipt-free settlement decision no longer lives as private policy in the -`epiphany-swarm` binary. Resident Self now owns the whole transition; the binary -supplies only exact child observation, brake/shutdown/timeout state, time, and -configured cooldown. The old binary cancellation classifiers and settlement -function are deleted. - -The admitted-model-direction fulfillment test now crosses the real ownership -boundary: it persists the grant and active lease, atomically opens the resident -coordinator incarnation, admits an authenticated typed terminal result, then -observes the coordinator missing before any run receipt. Resident Self records -the exact coordinator death recovery and closes the original grant as -`recovered-fulfilled`. The pressure remains consumed by that grant, replay is -refused with byte-identical resident state, and Heartbeat cannot issue a retry. - -Full core verification passes 661 tests with one intentional ignore; all seven -swarm tests pass without warnings. Commit, exact package, and copied Linux proof -remain. Actual c006 is still braked and stopped. - -## Fulfilled-before-receipt Linux fixture accepted — 2026-08-10 - -Source `2e66433f519327623614d26e46ac8ff5d75bbd0a` is pushed. Exact package -`sha256-1863385b98acfb2017eb9df8401941073fef59f08ce0555c396fbd612f35ff73` -with witness -`sha256-02f1d04fb10f804206302dbe20ea0298af7690a4887fc6eddd12cfc7d2d68822` -authenticated 24 binaries with zero warnings. Cargo took 7m03s and the successful -container took 7m14s. The first package invocation failed before Cargo because -the source volume was read-only; that receipt is preserved beside the success -under `.epiphany-run/linux-package-2e66433f`. - -A fresh quarantined Linux fixture linked against exact source `2e66433f` built -an authenticated admitted-model-direction request, launch, and terminal result; -atomically opened the exact resident coordinator incarnation; and confirmed -typed fulfillment with zero coordinator receipts. Resident settlement returned -`completed`, wrote one `recovered-fulfilled` grant/ack, left the pressure -consumed by the original grant, and cleared the lease. Replay exited 1 with a -byte-identical resident store. After Heartbeat consumed the ack, retention -retired exactly one lifecycle and still produced no retry grant. Accepted -receipts are under `.epiphany-run/fulfilled-before-receipt-2e66433f-r4`; r1-r3 -are preserved fixture failures that exposed missing cache-pull, consumed-grant, -and immutable-child-claim setup. - -The Linux transition was executed by a fixture linked against exact pushed -source, while the corresponding release was separately authenticated. Do not -claim packaged CLI execution yet. Next drive the same state through the exact -packaged `epiphany-swarm`, then cover proposal Modeling and Imagination and -runtime retention of terminal worker attempts. Actual c006 stays braked. - -## Packaged fulfilled-before-receipt accepted; retention fence corrected — 2026-08-10 - -The exact `2e66433f` packaged `epiphany-swarm` directly consumed the copied -pre-fulfilled admitted-model-direction state and exited zero with `completed`. -The resident store has no active turn; the exact grant and acknowledgement are -`recovered-fulfilled`; and the pressure remains consumed by that original -grant. The runtime held zero coordinator receipts. The proof used exact -packaged repository-Body bind and observation first, and deliberately separated -cognitive runtime `worker-continuity-fixture` from release runtime -`epiphany-starfire-linux`. Receipts are under -`.epiphany-run/fulfilled-before-receipt-2e66433f-packaged`. - -The follow-up retention negative found a production fence defect: resident -lifecycle retention derived its CAS snapshot from the owner-only cache, while -provider readiness is a legitimate foreign envelope in the same backing file. -After the first readiness publication, later retention therefore refused every -full-snapshot CAS. Retention now reads the complete backing snapshot as its -fence while selecting and deleting only the exact closed lifecycle families. -A hostile co-resident readiness test proves byte identity. Full core tests pass -662 with one intentional ignore; all seven swarm tests pass. Rebuilding the -exact-source fixture against this cut retired the packaged proof lifecycle and -Heartbeat still issued no retry. - -Next: commit and package the retention-fence cut, replay it through the exact -package with the readiness row already present, then cover proposal Modeling, -Imagination, and terminal-worker-attempt runtime retention. Actual c006 remains -braked and stopped; Yggdrasil never builds. - -## Co-resident resident retention accepted packaged — 2026-08-10 - -Source `52ee6b535eadb7b492190591593b682c3746867e` is pushed and packaged as -`sha256-24a8faee17bc28fa7eca877748cfa14472832881352f251b2d4b4f33db823771` -with witness -`sha256-c1d0f4f1d9a5d0a253eefacf50d1901d2b8de062bcef5e692bda2a6f39d5af48`. -Independent inspection authenticated 24 binaries and zero warnings. Cargo took -7m06s. The first package attempt failed before Cargo because the source volume -was mounted read-only; its receipt is preserved with the successful attempt -under `.epiphany-run/linux-package-52ee6b53`. - -Fresh copied state under `.epiphany-run/resident-retention-52ee6b53` used the -exact packaged Body binder/observer, release publisher, and `epiphany-swarm`. -The first resident cycle settled the zero-receipt admitted-model-direction -result as `recovered-fulfilled`, exited zero, and published provider readiness -into the resident store. Heartbeat then consumed the exact terminal ack. A -second exact packaged `once` with closed-lifecycle retention zero exited zero -`sleeping`, removed the pressure/grant/ack family despite the co-resident -readiness row, retained no active turn, and could not mint a retry. A replay -found no lifecycle to retire and still returned no grant. - -Next: use the same resident-owned settlement path for an authenticated -Imagination candidate chain, including exact request, launch binding, worker -launch/result, death recovery, retention, and no-retry proof. Proposal Modeling -and runtime retention of terminal worker attempts follow. Actual c006 remains -braked and stopped; Yggdrasil never builds. - -## Imagination fulfilled-before-receipt source gate — 2026-08-10 - -The existing Imagination fulfillment test now crosses the complete resident -ownership boundary. It opens a real typed request and lease, proves a candidate -without its exact launch binding remains pending, admits the authenticated -worker launch/binding/result companion, and requires zero coordinator receipts. -Exact missing-child recovery then closes the original grant -`recovered-fulfilled`, preserves its pressure as consumed, refuses replay with -byte-identical resident state, and yields no retry. After Heartbeat consumes the -ack, lifecycle retention removes the exact family and still yields no retry. -Full core tests pass 662 with one intentional ignore; all seven swarm tests pass. - -This is a source verification pass only; `52ee6b53` already contains the generic -runtime and resident behavior, but a fresh exact packaged Imagination state run -is still required for direct binary provenance. Proposal Modeling and terminal -worker-attempt retention follow. - -## Imagination fulfilled-before-receipt accepted packaged — 2026-08-10 - -Fresh state under `.epiphany-run/imagination-fulfillment-52ee6b53` contains an -authenticated Imagination request, admitted model basis, deterministic candidate, -exact launch binding and launch-document hash, and terminal role result with zero -coordinator receipts. After exact packaged Body bind/observation and release -publication, exact `52ee6b53` `epiphany-swarm once` exited zero `completed`, -closed the original grant `recovered-fulfilled`, preserved its pressure consumed -by that grant, and cleared active authority. - -Heartbeat consumed the terminal ack. A second exact packaged cycle with -closed-lifecycle retention zero exited zero `sleeping`, removed the complete -pressure/grant/ack family, and retained no active turn. Replay reported no -lifecycle to retire and no retry grant. The fixture's first result admission -failed closed because the producer-owned candidate companion was absent; the -corrected attempt persisted that typed evidence before result admission. No -production gate was weakened. - -Next: proposal Modeling is the remaining fulfilled-before-receipt variant. Its -immutable proposal/request/context/patch/launch/result chain is stronger and -must be mapped before constructing live state. Runtime terminal-attempt -retention follows. Actual c006 remains braked and stopped. - -## Proposal Modeling fulfilled-before-receipt source gate — 2026-08-10 - -The real runtime proposal-admission fixture now crosses the resident boundary. -It preserves the full immutable chain: user proposal and payload, selected -request, runtime/thread/Body-bound Modeling context, exact launch binding and -launch-document hash, successful Modeling result, Evolution patch, and one -safe proposal-citing routeable frontier. No parallel fulfillment schema exists. - -With zero coordinator receipts, resident Self verifies that runtime-owned chain, -records exact coordinator death recovery, closes the original grant once, and -refuses replay with byte-identical resident state. Heartbeat consumes the ack; -retention removes the lifecycle; and no later grant can appear. Full core tests -pass 663 with one intentional ignore and all seven swarm tests pass. - -Direct packaged proposal evidence remains open. Unlike the two consideration -lanes, its immutable worker launch includes authenticated repository Body basis, -so a faithful fixture must construct it inside the Linux path namespace after -packaged Body binding. Do not add a test-only production writer merely to make -that receipt convenient. Next map terminal-worker-attempt retention and then -choose the smallest Linux-native construction path. - -## Terminal worker-attempt retention ownership mapped — 2026-08-10 - -There is no production retention owner for outer role-worker attempts. Existing -completed-session archival deliberately accepts only model-adapter families and -refuses outer worker launches/results. A narrow deletion of process claims is -invalid: `runtime_typed_request_attempt_exists` interprets a launch with no -claim as live, so deleting a terminal claim resurrects retry exclusion. A -narrow deletion of a terminal result can turn fulfilled request state back into -pending. A digest/count retention head cannot safely replace either authority. - -Owner: runtime spine owns one typed archive transaction per immutable worker -attempt. Inputs are the exact typed request, launch, lane-specific launch -binding, native process claim, terminal worker result and companion, job/event -family, downstream references, and explicit resident cross-store liveness. -Output is one per-attempt archive tombstone plus atomic deletion of only that -exact attempt family. The tombstone is terminal evidence for retry and -fulfillment readers; it is not a generic completion head and cannot satisfy a -different request or job. - -The archive must refuse while resident prepared/active authority or an -unconsumed terminal acknowledgement names the attempt's request/grant; while a -claim is nonterminal; while a downstream review/admission still needs exact -result bytes; or when the lane-specific family is incomplete. Proposal -Modeling, Imagination consideration, and admitted-model-direction consideration -share the archive primitive but supply distinct family validators. Unknown -runtime rows remain byte-identical under a full-snapshot fence. - -Deletion line: launch, terminal claim, result, lane binding and companion, and -terminal job/event rows may disappear only in the same CAS that creates the -exact tombstone. Request/proposal/model/admission state remains producer-owned -unless a later independently mapped lifecycle archive owns it. Readers must -consult tombstones before treating missing claims/results as live or pending. - -Next implement the archive and hostile/non-resurrection tests before packaging. -Direct packaged proposal Modeling construction remains a later Linux-native -evidence task. Actual c006 stays braked. - -## Grant-owned lifecycle sight accepted; structured-output retry wound — 2026-08-11 - -Exact pushed source `34d75d05d11852fdc9ebacc2d08f9f63a774114a` adds a -bounded `epiphany_state.resident_grant_lifecycle` organ. It reads only an -explicitly bound resident store. The exact `ResidentSelfHeartbeatGrant` plus -resident active/prepared state remain the owners; scheduling and projection -share `resident_self_grant_is_pending`. Acknowledgements, retention heads, and -artifact names remain evidence or notification only. - -Focused reconstructed-diff tests passed across resident Self, the tool runtime, -OpenAI/model runtime wiring, and the coordinator. The full core library passed -670 tests with one intentional ignore before the exact reconstructed diff was -rechecked by focused suites. Exact Linux packaging produced 24 binaries with -zero warnings, release -`sha256-718316c4372f3caf127579cd8a185fe11717f2370f1418d9a1f465a0efa54b8c` -and witness -`sha256-58d4c05c3de5b9c07ea76e06a2f60af94571a0f053da49de65629f413e0cbd92`. -Cargo took 3m21s for the core-touching relink. - -On copied c006 state, proposal Modeling invoked the typed lifecycle tool. The -first three worker attempts failed the strict `epiphany.worker.role_result.v3` -contract: one duplicated `checkpointSummary`, then two duplicated `verdict`. -Resident Self did not treat those failures as fulfillment and canonically -requeued without Hands, Persona, or deployment authority. Attempt four produced -an admitted result: sampled older terminal grants remained `launchable=false`, -and the active consumed grant was also non-launchable while awaiting terminal -settlement. - -The copied brake was engaged before intervention. Heartbeat stayed stopped; -resident Self alone replayed the completed typed evidence, cleared the exact -active turn once at revision 74, then projected `braked` with no new grant. -Both copied owners exited zero. Actual c006 remained alive and cognitively -braked throughout. Receipts are under -`.epiphany-run/grant-sight-live-34d75d05` plus the sealed copied volumes. - -Next: inspect generated role-result schema, role prompt, provider response, and -strict ingress decoder as one ownership boundary. Remove the cause of duplicate -top-level fields without weakening admission or adding a repair parser. Repeat -the copied proposal and require first-attempt completion, exact one-grant -terminalization, and zero external consequence. Yggdrasil never builds. - -## Copied frontier turnover exposed stale typed-request resurrection — 2026-08-11 - -Actual c006 remains exact `c9a2a979`, alive and cognitively braked. A stopped -copy of exact accepted `d4907ee8` state accepted proposal -`proposal-close-organ-loop-plan-reconcile-20260811`, issued one proposal -Modeling grant, admitted its first result, and settled its downstream review. -The Modeling transaction advanced RepoModel while an older -`AdmittedModelDirectionConsiderationRequest` still named the prior exact model -revision and hash. Its coordinator then failed with `model direction -consideration request is stale`. Restart recovery requeued and relaunched the -same impossible typed pressure until the copied brake was engaged. Both copied -owners stopped cleanly; actual c006 was untouched. Receipts and before/after -hashes are under `.epiphany-run/frontier-turnover-d4907ee8-plan-reconcile`. - -Owner map: runtime RepoModel owns whether an admitted-model-direction request -has been superseded; resident Self owns terminalization of the exact grant. -Inputs are the structurally valid request, its bound revision/hash, the current -RepoModel, exact resident lease, and exact coordinator receipt. The output for -a superseded request is one terminal grant and acknowledgement with status -`superseded`, using the real coordinator receipt ID. Failure counters, pressure -requeue, retries, and new grants are forbidden outputs. Receipt text, error -strings, cooldown, and pulse timing are observations, not supersession owners. - -Source now exposes the narrow runtime-owned supersession predicate and checks it -at resident settlement, including the race where the model advances during -fulfillment verification. Focused proof passes 31 resident tests, four -admitted-model-direction tests, and all eight swarm tests. Packaging and exact -copied-state replay remain required before acceptance. - -The attempted fresh `epiphany-repo-work-order-family-smoke` was rejected as an -active readiness path. Its historical `epiphany-work` mutation surface is -deliberately inert and refuses acceptance; runtime-spine RepoModel/RepoFrontier -is the canonical live workflow. Do not restore a second repo-swarm owner or -revive the old scheduler to make archaeological smokes green. - -Next: commit and push the bounded source/Mind cut, package the exact commit on -Starfire, then replay copied state. Require one superseded terminal grant and -acknowledgement, no failure count, no requeue or regrant, zero external -consequence, and clean shutdown. Then inspect the next canonical typed action. -Yggdrasil never builds. -## Failed outer-worker attempt retention cut in source — 2026-08-10 - -Runtime spine now owns `EpiphanyArchivedRuntimeWorkerAttempt` for failed or -cancelled typed attempts. Resident Self projects every typed request still -named by a durable grant; serve/once compacts resident lifecycles first, then -passes that surviving set into runtime retention. The runtime refuses a live -request byte-identically and otherwise replaces the exact launch, terminal -claim, lane binding, terminal job/result/events with one snapshot-fenced -tombstone. A focused proposal-Modeling test proves refusal, retirement, -idempotence, and that deletion cannot recreate retry suppression. Successful -attempt retirement remains open because its tombstone must preserve the same -authenticated fulfillment answer currently owned by the result/binding chain. -## Successful proposal worker archive preserves fulfillment — 2026-08-10 - -The worker-attempt tombstone can now carry a validated terminal result ID and -answer `runtime_typed_request_fulfillment` after live worker launch, claim, -result, binding, job, generic result, and events are retired. Proposal Modeling -retirement additionally requires a `RepoModelAdmissionReceipt` for that exact -worker result, so runtime retention cannot delete a patch still awaiting Mind. -The admitted model receipt remains byte-live. Focused proof covers resident -liveness refusal, exact live fulfillment before retirement, identical archived -fulfillment afterward, and a concurrent unrelated write that defeats the full -snapshot CAS without losing either side. Imagination and admitted-direction -successful companion preservation plus production enumeration remain open. -## All three successful worker lanes preserve semantic companions — 2026-08-10 - -The existing resident model-direction and feedback-Imagination fulfillment -tests now continue through Heartbeat ack consumption, resident lifecycle -retirement, and exact worker-attempt archival. Both prove archived fulfillment -still resolves while the exact producer-owned -`AdmittedModelDirectionConsiderationResult` or -`ImaginationConsiderationCandidate` remains byte-equal. The fixture initially -placed the worker job in the coordinator's jobless Continuity session and was -correctly rejected as competing authority; the accepted proof uses a distinct -outer-worker session identity. Failed production enumeration also now proves -two terminal attempts retain the newest and archive the older without -resurrection. The archive tombstone is published in the runtime CultNet schema -catalog. Source packaging and copied-state live proof are next. -## Mechanical package rejected; failed archive provenance cut — 2026-08-10 - -Exact `452c250e` mechanically packaged in 7m14s as release -`sha256-e585f91054e3333d6fe7d52912e0338fdd4793f413eaebd9a278eb3836a97d63` -with witness -`sha256-1f3087d589499c73a98fdfb5909850c8c0ae416d7e97d0a20998dfb644f774f0`, -24 binaries, and zero warnings. It is not accepted for runtime proof: inspection -found that failed-attempt archival trusted the typed request echo without -authenticating the persisted request, lane binding, launch hash, role, runtime, -thread, and projected context. Source now validates that immutable chain for -all three lanes before any archive. A hostile proposal binding hash refuses -byte-identically. The stronger check also exposed a model-direction fixture -that projected a default model; the fixture now uses the admitted model and -result admission itself requires the projected model hash. Repackage the new -commit; do not publish or use the 452c release as accepted evidence. - -## Packaged supersession proof and construction wound — 2026-08-11 - -Exact `b81b59a7` packages as release -`sha256-7c1a739c4b287c49051ab7aaab9a9541320f2d768e6b846d84b7bf290acbecc2` -with witness -`sha256-c9d042a09b8fe105cceab1bc2c23c290cea94c8e7af11322ef030e34fb1c7573`, -24 binaries, and zero warnings. The first package took 6m15s. An identical warm -replay produced the same release and witness, but Cargo took 23.23s after -transient fixture construction disturbed the shared source fingerprints. -Receipts are `.epiphany-run/linux-package-b81b59a7` and -`.epiphany-run/linux-package-b81b59a7-warm`. - -A purpose-built copied CultCache fixture held one active -admitted-model-direction grant and exact receipt against RepoModel revision 1, -then advanced the model to revision 2. Exact packaged Self terminalized that -grant once as `superseded`, recorded the real receipt, left runtime bytes -unchanged, and created no failure count, requeue, or external consequence. -Exact packaged Heartbeat produced no grant through three braked and three -released iterations. Receipts and before/after hashes are under -`.epiphany-run/b81-superseded-fixture`. - -The earlier copied turnover fixture was rejected for this proof because it -retained unrelated proposal authority. Its `activeLeaseObservation:none` -projection described absence of a live process, not absence of a durable active -lease. Do not use that projection as an authority-free predicate. - -The next rite maps build ownership before editing. Preserve the deterministic -content-addressed package cache and single publisher, but separate transient -test/fixture construction from release Cargo fingerprints and avoid linking a -second monolithic release graph merely to create typed state. The native state -reader itself required a 61-second debug build during this phase, confirming -that operator sight still owns compilation work it should not need. Actual c006 -stays exact `c9a2a979`, alive and cognitively braked. Yggdrasil never builds. - -## c006 braked endurance retirement — 2026-08-11 - -Actual c006 exact `c9a2a979` remained cognitively braked for 10h23m. Heartbeat -stopped cleanly after 36,700 iterations: 36,624 brake refusals, 70 historical -routine iterations, no new grant, and only 72 retained pulse directories / 4.2 -MiB. Resident stopped cleanly at revision 34, braked, with no active turn. Both -containers exited zero. Runtime, cognitive local Verse/brake, and release Verse -hashes remained byte-identical; only Heartbeat and resident published their -canonical shutdown state. Containers and named volumes remain intact. Exact -hashes and timestamps are in -`.epiphany-run/c006-endurance-retirement-20260811/receipt.md`. - -The run also falsified its ad hoc container launch contract. Docker used -unbounded `json-file` logging, producing about 22.0 MiB of resident output and -15.3 MiB of Heartbeat output. c007 must have one bounded stdout/stderr owner: -explicit Docker rotation or a proper supervised service. Do not restart c006 -merely to preserve the appearance of motion. - -The build audit found no new release-graph defect. The 23.23-second b81 warm -Cargo run followed illicit transient edits inside the forge-owned exact-source -cache; restoring bytes left different fingerprint mtimes. Separately, the -bootstrap rite invoked `cargo run` without the mandated shared target and paid -61 seconds to compile a duplicate debug graph. The existing shared-target -`epiphany-state.exe` returned the same Mind status in 37.9ms. `AGENTS.md` now -names that build-free path and the correct shared-target fallback. Preserve the -single deterministic release publisher; do not split it to fix operator -contamination. Yggdrasil never builds. - -## c007 root Continuity fault and Body preflight — 2026-08-11 - -Exact `d296c424` packaged as release -`sha256-fc5bf3a8e8377c1effec824497184278909ee463cbff66278da35c00bb797001` -with witness -`sha256-cae5a0e9d4483d9c8a158e42202de11181094517a547b42930f410e579703c04`, -24 binaries, and zero warnings. The first clean pass after the contaminated -fingerprint rebuild took 5m10s Cargo; the identical warm replay took 0.80s -Cargo and 9.20s wall. Warm packaging is no longer the iteration bottleneck. - -c007 launched with Docker's bounded `local` log driver. A fresh typed proposal -then exposed two pre-cognition faults. The slim resident image lacked `git`, but -readiness did not prove that required Body capability, so the same immutable -proposal failed before worker launch 59 times. A git-capable c007c reached -Runtime Continuity and then failed because the operator had mistaken six -long-lived Active sessions for leaked work and generically completed them. -Closing `epiphany-main` was invalid: every coordinator job uses it as the -long-lived root session, so later work was refused as terminal. The incorrect -receipt is explicitly marked operator corruption under -`.epiphany-run/c007-d296c424/receipt.md`. c007c remains alive and cognitively -braked; no failed attempt is accepted cognition. - -The active cut assigns ownership to Runtime Continuity. The canonical -`EPIPHANY_RUNTIME_ROOT_SESSION_ID` supplies coordinator launch, generic session -closure refuses it before mutation, and a narrow `repair-root-session` API/CLI -requires the exact Completed root plus its deterministic Continuity completion -event, no archive, and no open jobs. It atomically restores Active and deletes -only that event behind the full snapshot fence. Resident serve/once now proves -`git --version` before taking its singleton or consuming pressure. Focused root -repair, ordinary closure, resident Body-preflight, and 34 coordinator-launch -tests pass. This source is still uncommitted/unpackaged. Next commit/push, -package exact source plus identical warm replay, then use only the authenticated -repair CLI on the preserved c007 state before releasing the proposal once. -Yggdrasil never builds. - -## c007 authenticated root recovery and resumed Modeling — 2026-08-11 - -Commit `fb873927` packages the root-session ownership cut and resident `git` -Body preflight. Exact release -`sha256-b72fbae12b8d02fa00aee50bf41ee195a67d9564addcab5294dfc4a68fe816a2` -with witness -`sha256-38aadfd9dc94201fa1892658a6e91badd721058897b9f9177bb359125a99c2e6` -passed 24-binary inspection with no warnings. The new content-addressed graph -took 13m40s and peaked near 4.4 GiB on Starfire; identical warm replay took -8.51s wall/0.83s Cargo. Warm iteration is accepted, while the cold per-source -monolithic compile remains a named architectural cost. Yggdrasil never builds. - -Against preserved c007 state, exact packaged generic closure refused the root -exit 1 and left runtime SHA-256 -`bc292cfb77cd9c575c92cd0e21fad04496ae8b509a4fcfd9da7ea3685fa318d8` -unchanged. Exact `repair-root-session` restored `epiphany-main` Active, removed -its deterministic completion event, and produced runtime SHA-256 -`00696a1ecfc9a5c52ead5ead7cd8587815cb2cb59b7d18242d819e7c35971e53`. - -Released c007 attempt 61 then opened a new coordinator job under the restored -root, launched detached Modeling job `82f2e1d0-338b-43d0-91a2-915e9947c9b2`, -and made resident Self hold `awaiting-fulfillment`. Exact typed fulfillment -closed once, the continuation accepted Modeling, and a following admitted -model-direction consideration also completed and acknowledged exactly once. -The brake was reengaged during settlement; c007c is now braked at revision 286 -with no active turn. Final operator-safe action is `awaitFrontierProposal`, -target Imagination: Mind accepted the model, no Hands frontier exists, and no -further Modeling may launch without a new typed proposal. Receipts are -`.epiphany-run/c007-root-repair-fb873927/`. - -Next map Native Imagination ingress, restart resident serve onto exact fb873927 -to prove its Body preflight live, then exercise one typed Imagination proposal -through detached worker, typed candidate, resident fulfillment, and continuation -without Hands or public consequence. Reengage the brake at the boundary. - -## c007d Native Imagination fan-out pressure — 2026-08-11 - -c007c stopped Heartbeat and resident cleanly with exit zero. Exact fb873927 was -published into the release Verse, the mounted workspace advanced to current -`0a3ca20d`, and c007d restarted both owners from authenticated fb873927 with -bounded Docker `local` logs. Resident production serve passed the new `git` -Body preflight; both owners were healthy and braked before ingress. - -Proposal `proposal-c007-soul-verification-audit-20260811` selected request -`repo-frontier-proposal-modeling-79838d351edef9f0346ec225377ca5609188b849a478038c0bc85c8b154a481b`. -It completed one detached Modeling fulfillment. Native Imagination's -admitted-direction lane then produced several authenticated option drafts; -runtime promotion created inert autonomous proposals and exact Modeling -selections one at a time. The first autonomous request -`repo-frontier-proposal-modeling-460467352543b508aa784f3e110474220be3a037d9c8d066b232cf06bdaf9646` -also fulfilled once. The brake settled at resident revision 294 with no active -turn; request -`repo-frontier-proposal-modeling-ef8245a7349c5cf78e3c2fbd6d4b570912aac522edb93dc695dd257ab448efe1` -remains pending and untouched. No Hands, Persona, release, deployment, or -external consequence authority was granted. - -The live cascade exposed an ownership gap: admitted Imagination -`option_drafts` had no structural maximum in either declared output schema or -runtime validation. Scheduler FIFO and one-at-a-time promotion cannot bound -the durable queue a single worker result may mint. The active source cut adds -shared `MAX_OPTION_DRAFTS = 3`, emits that as schema `maxItems`, and rejects -larger admitted results in Rust. Commit `bc0806b5` is pushed. A current Linux -packager bootstrap (SHA-256 -`b14405aeacb008b0a075cf409ccf7239b2a48c8b5af5d380e8aed64ba2e8a34d`) -then restored the already-designed stable `/source/repo-live` forge path. The -one-time path migration compiled fb873927 in 4m36s; the distinct bc0806b5 core -change completed in 1m34s, down from the stale per-commit clone path's 13m40s. -An identical warm replay took 8.32s wall / 0.77s Cargo and reproduced release -`sha256-3214699820704481268f3f52de9a9dd86948d424ff556177eb60e45330ad414f` -and witness -`sha256-6d03e787da348d9901aae72fa6fe94e1cbe31b4db97d95e8bf05303bc65029cc` -across 24 binaries with zero warnings. Receipts are -`.epiphany-run/forge-crosscommit-*` and -`.epiphany-run/packager-bootstrap-bc0806b5`. - -c007d stopped both owners with exit zero. The workspace advanced to exact -bc0806b5, the release was published, and c007e restarted the exact authenticated -body with bounded Docker logs. After brake release, a stored safe continuation -launched the pending proposal's Modeling worker. The already-enqueued typed -proposal grant then correctly refused a duplicate unsuperseded launch, retained -the same active lease as `awaiting-fulfillment`, authenticated worker result -`result-worker-8ddf57c1-96b4-4a60-ae8b-b24404e9ce2f`, terminalized once, and -was acknowledged by Heartbeat. The apparent duplicate-launch failure was -therefore fail-closure, not corrupt state. The true wound was that the failed -coordinator receipt could not derive review pressure for the valid unaccepted -typed result. c007e is braked at resident revision 302 with no active turn; -status derives `reviewModelingResult`, `modelingResultProposalBound=true`, and -no pending proposal request. - -The active source cut preserves the failed receipt as process evidence but lets -the exact fulfilled proposal result own review readiness. It requires the -failed receipt, its grant and launch digest, one terminal acknowledgement, the -runtime-owned typed fulfillment, the current Modeling job link, and absence -of prior acceptance before deriving only `reviewModelingResult`. Typed -completion now records terminal status `fulfilled` instead of copying the -process receipt's status. Thirty-one resident tests, nine swarm tests, and the -new hostile failed-receipt/valid-result lifecycle test pass. Commit/package and -exact c007e continuation replay remain next. Yggdrasil never builds. - -Commit `2e1ccaf7` packaged as release -`sha256-243899f155e06e043de4c0d0ec7c6a0ab80296a6deb7ba83229b032555b06f29` -with witness -`sha256-c7b8dc0399455173f1856bda9cbbe6353f58f4890c7d3f8dc89606921865cd70`; -Cargo took 1m24s changed and 0.88s warm with identical output. c007e stopped -both owners exit zero and c007f started exact/authenticated/braked at revision -302. Live release then falsified one test-only assumption: the Modeling runtime -link's `runtime_result_id` remains absent until acceptance, so requiring it to -authorize pre-acceptance review is circular. Resident failed closed exit 1, -the cognitive brake was immediately reengaged, Heartbeat remained alive, and -receipts are `.epiphany-run/live-swap-c007f-2e1ccaf7`. The corrected source -requires the exact Modeling job link plus runtime-owned typed fulfillment; its -focused lifecycle test now explicitly proves recovery while link result ID is -absent. Package/restart/live replay of this correction is next. - -Restarting exact fbd57b9b braked exposed a separately preserved grant from the -older `launchModeling` continuation. The active source cut now revalidates -receipt-derived launches at preparation: terminal Modeling evidence overtakes -the stale launch, and one snapshot-fenced transaction terminalizes the exact -unlaunched grant as `superseded`, preserves the consumed pressure, and emits a -receipt-bound Heartbeat acknowledgement. The focused continuation test proves -supersession and then proves the newer `reviewModelingResult` continuation can -prepare normally. Commit/package/live replay remain next. - -Commit `3a5d2b5e` is pushed and packaged as release -`sha256-84af3da8d2a2e170aa0611e48367eac4ecf5f66b2a2da763dc3045c5ad360177` -with witness -`sha256-589ff2ca11392b02fee9cb5d3a0209d958fc47cc3695f82bb6e5bed08d4c4463`; -Cargo took 50.87s changed and 0.81s warm with identical output and no warnings. -c007g stopped both owners exit zero and c007h restarted exact/authenticated. -Live release terminalized the preserved launchModeling grant as `superseded` -without a coordinator process, Heartbeat consumed that acknowledgement and -issued the exact failed-receipt `reviewModelingResult` continuation, and the -coordinator accepted `result-worker-8ddf57c1-96b4-4a60-ae8b-b24404e9ce2f` -once. A previously admitted model-direction grant crossed the brake write but -used existing fulfillment and completed canonically. c007h is now braked at -revision 312 with no active lease. Exact status derives -`awaitFrontierProposal`, Modeling accepted after Research, proposal bound, no -pending proposal, no Imagination frontier, and no Hands consequence. Receipts -are `.epiphany-run/forge-crosscommit-3a5d2b5e*` and -`.epiphany-run/live-swap-c007f-2e1ccaf7`. - -## Canonical brake closes direct daemon actuation - 2026-08-11 - -The non-repository actuator audit found one real Idunn bypass. The default -brake listed `daemon.lifecycle_poke`, but explicit canonical engagement replaced -that list with `canonical_epiphany_swarm_brake_protected_surfaces`, which -omitted it. Therefore `epiphany-daemon-supervisor reconcile --restart-command` -could reach an arbitrary operator-supplied executable while an all-scope brake -was engaged. Commit `5a46f569` restores that surface to the canonical owner -list and adds an exact engagement test. This is a brake ownership repair, not a -new Hands gate: Idunn still owns permitted deployment restart actuation. - -The first packaged probe also exposed two dead assertions in -`epiphany-verse-query smoke`: one demanded the former EpiphanyAgent path instead -of the fixture topology's Body domain; another demanded a removed -`imagination-consensus` receipt row with no producer or report path. Commit -`3fdff19f` compares poke routing to the topology document that owns it and -deletes the ownerless receipt assertion. Nineteen Verse-query tests and the -full native Verse smoke pass. - -Exact `3fdff19f` packages as 24-binary release -`sha256-bd0062904fa8e7097946c6fd735191de43ff04a89d1c3c29c0c86f876815fb31` -with witness -`sha256-a051980f70b13d9dafa014fedc7fc636eb075a9fc85dc53e3a94081bcc3fe3e0`; -changed Cargo took 30.66s and an identical warm replay took 0.82s with zero -warnings. Its packaged Verse smoke passes. On the resulting quarantined copied -state, a forced `/bin/sh` restart attempt refused exit 1 before execution, -preserved the exact local-Verse SHA-256, and created no marker. Receipts are -`.epiphany-run/forge-crosscommit-3fdff19f*` and -`.epiphany-run/brake-actuator-proof-3fdff19f`. - -Actual c007h remains exact `3a5d2b5e`, alive, braked at revision 312, and -untouched. Continue classifying remaining non-repository actuators by their -real owner; do not manufacture frontier work or build on Yggdrasil. - -The remaining process inventory found one additional bypass in the Windows -Unity bridge. Its guidance claimed ownership of `-executeMethod`, but generic -`run -- ...` accepted a caller replacement and could therefore invoke an -arbitrary project static method. Commit `5ccf4cf8` separates caller command -construction from internal named-probe construction and rejects -`-executeMethod` case-insensitively. Commit `d7957b42` corrects the full smoke: -harmless generic flags remain plannable, hostile method override returns -`error`, and named probes alone carry the exact resident editor method. Two -focused bridge tests and the full Windows bridge smoke pass. The rebuilt -standalone executable SHA-256 is -`e4a4c50eb575005f956cedb625386ec263cb973b08e8f51348cab539ef728034`; -the hostile resolved-editor dry-run refuses exit 1 before command-artifact -publication. Receipt: -`.epiphany-run/unity-execute-method-refusal-5ccf4cf8-exact`. - -The other production `Command::new` paths retain coherent owners: release -construction is explicit forge authority; resident Self launches witnessed -coordinator/model binaries; Persona invokes Bifrost with speech audit, -identity, and Heimdall capability; Rider opens only an in-project reference -under explicit `--launch`; repo birth changes branches only under explicit -create/switch flags; native process observation is sight. No authenticated -agent tool-invocation surface exposes these utilities. The bounded actuator -audit is complete; select the next Soul/Mind matrix gate from current source. - -The first Soul verifier audit found no aggregate-projection verdict shortcut. -The causal consumers reload the exact accepted Verification result, typed -verification request, frontier route, current item/model, and Hands chain; the -mixed-chain and unrelated-verdict tests refuse substitution without mutation. -One obsolete authority aperture did remain: `put_soul_verdict_receipt` was a -public standalone writer even though production creates the verdict only as a -prerequisite in the atomic Mind acceptance transaction. It is now compiled -only for crate tests and no longer exported. Ten verdict tests, the focused -Soul acceptance test, and warning-free library check pass. Package this cut, -then continue with the next unproven Soul/Mind boundary. - -Exact `9370e47a` packages that Soul cut as warning-free 24-binary release -`sha256-fe3e6c2465017f45649bef61fed1e54b5502f7963c83526fd1f5a791a7a35ac8` -with witness -`sha256-712372f40acd4250c54d4d328a79195d6c955cd9c22e7024abb51c038b043942`. -The package contains no standalone Soul-verdict command, so there is no honest -copied-state CLI invocation for the removed actuator; hostile causal-chain -falsification remains in the exact source verifier suite. - -The next Mind audit found the same obsolete fixture aperture. Production -publishes `MindGatewayReview` and `MindStateCommitReceipt` only beside the exact -coordinator state transition through `commit_state_with_mind_witness`, but both -had exported standalone shape-only writers with no production caller. Those -writers and re-exports are now test-only. The atomic state-and-witness test, -the direct historical-family fixture test, and production library check pass. -Commit/package this cut before selecting the next organ boundary. - -Exact `d4f4f145` packages the Mind portion as warning-free 24-binary release -`sha256-b2490d04a1151d10b8a81b79cd7e56d5544d502829b9b51e1af6cea3a5477d11` -with witness -`sha256-3ac4f12aebe70ae854b9156969ee374838c1e48461357a57632035a18bafd058`. - -The same bounded audit then completed the acceptance prerequisite family. -`EyesEvidencePacket` and `ContinuityRecoveryReceipt` are minted only beside an -accepted Research or Reorientation state transition, yet their historical -fixture writers were also public. They are now test-only and unexported. -`SubstrateGateRepoAccessGrantReceipt` remains public because coordinator and -Hands paths genuinely produce it independently. All seven coordinator -acceptance tests, the historical-family fixture, and production library check -pass. Package this final family cut, then move to a larger live matrix gate. - -Exact `8ebe56f1` packages the completed family as warning-free 24-binary release -`sha256-2707ff42e48dd8640b8a962536972799dca9a1f49346d3b8d05695e7fa826a8e` -with witness -`sha256-6003630b550041f90f76ec6261372e6925fd4144ee3daee1d0e2f6864f217289`. -The release published into the live Verse. c007h stopped Heartbeat then resident -Self with exit zero; c008 restarted both on the same named state/workspace -volumes, bounded 10 MiB x3 local logs, exact authenticated readiness, revision -312, no lease, and `awaitFrontierProposal`. The workspace then advanced cleanly -from `3a5d2b5e` to exact `8ebe56f1`, preserving only its untracked `.epiphany/` -runtime configuration. - -A genuine typed operator pressure -`operator-current-body-audit-8ebe56f1` exposed a live ownership fault. -Heartbeat granted attempt 1 and Self launched, but coordinator startup -terminalized the opened run because the existing canonical coordinator state -has no `UserObjectiveIntake`. Heartbeat acknowledged the failed grant and -committed attempt 2 before the canonical brake was re-engaged. State is -revision 316 with no active lease; attempt 2 remains unclaimed. The problem is -not missing legacy data: `intake_user_objective` is deliberately seed-only and -cannot own later resident directives. - -The source cut separates those authorities. Standalone coordinator startup -still atomically seeds the canonical Mind objective. A resident launch instead -authenticates its argv objective against the exact persisted prepared grant or -its canonically promoted active lease, plus child claim, process identity, -launch digest, and objective digest. It then treats the directive as per-turn -command context without changing the canonical objective. Wrong objective or -foreign launch refuses. The focused resident test proves both sides of the -prepare-to-active transition; the standalone seed-only test and -coordinator-runtime binary check pass. Package/publish this cut, -restart c008, release only for committed attempt 2, and require exact settlement -before re-engaging the brake. - -Exact `a07f6541` packages that directive cut as warning-free 24-binary release -`sha256-ba51cbac5fe2400c27497c5df92fe128ce083a29c45e9ccf5eb95d21ec807b26` -with witness -`sha256-01a6d5d74129ffb3096a3aa3f4ea7cd98d13af38b27d5322a8ab1d8f458d7a03`. -c008b authenticated committed attempt 2 after prepared-to-active promotion, -preserved the canonical coordinator objective, and settled the directive once -at resident revision 320. Heartbeat then advanced through proposal Modeling -and issued a continuation grant. Resident Self exited 1 with `autonomous -proposal promotion companion collision`, leaving an active lease whose process -is now missing. Heartbeat was stopped exit zero and the canonical brake was -re-engaged in the cognitive runtime namespace from the exact packaged Body. -Do not restart either owner yet. Preserve the collision as evidence, inspect -the proposal/binding/selection companion family and accepted result, repair the -promotion ownership/idempotence seam on copied state, and only then perform -exact-process receipt-free recovery of the stranded lease. - -## Causal thread recovery and live native Imagination - 2026-08-11 - -Copied c008b state proved the autonomous promotion family was complete. Exact -replay differed only because promotion reconstructed immutable companions from -the mutable singleton coordinator thread after resident bootstrap. Commit -`78ca972b` makes the admitted model-direction request own causal thread identity; -complete replay is byte-identical and a hostile partial family refuses without -mutation. - -The first exact restart then performed a legitimate two-cycle Continuity -recovery: the old proposal Modeling launch still had a nominally live process -claim, so duplicate launch refused; Self observed the exact incarnation dead -and terminalized it. The next retry exposed the same stale-owner veto in -proposal Modeling launch validation: request and proposal belonged to -`linux-eyes-tools-c005`, while the singleton projection named the resident -thread. Commit `d3e433fc` removes that veto and proves a launch after projection -transition atomically restores the admitted cognitive thread. - -Exact `d3e433fc` packages as 24-binary release -`sha256-11be5dae8429fcb6c604a15e8e122869f3ee60b9699831329b49fb62c1689768` -with witness -`sha256-217eafc8752d16fb249aad69b5dfc312e5fd507d2c05bff1cf5a1dbcc1b5ab32`; -changed Cargo completed in 20.96 seconds with no warnings. c009 stopped both -owners at exit zero. c010 authenticated the exact package while braked, then -live replay restored `linux-eyes-tools-c005`, launched fresh Modeling job -`a4495f79-6fe7-4c00-a71f-577fbc1988e1`, held `awaiting-fulfillment`, settled -once at revision 344, and accepted the downstream review continuation. - -The same released run then completed native admitted-model-direction -Imagination, emitted a new autonomous proposal, and completed two consequent -proposal Modeling families. One first worker attempt died; Runtime Continuity -made the exact second attempt eligible and it settled without dual live -authority. The canonical cognitive brake is engaged at revision 364 with c010 -resident and Heartbeat alive and no active lease. Current coordinator status is -`reviewModelingResult`; inspect and accept only exact authenticated typed -evidence before releasing another route. Receipts are -`.epiphany-run/c008b-promotion-collision-a07f6541`, -`.epiphany-run/c009-provenance-mismatch-d3e433fc`, and -`.epiphany-run/forge-crosscommit-d3e433fc`. - -The pending Modeling review was then accepted exactly. A second native -admitted-direction Imagination turn completed and settled, but produced no new -admitted work; released Heartbeat returned to routine physiology. The one -failed Modeling attempt in this phase was an operator-visible OpenAI adapter -HTTP 503 before usable output, followed by one exact successful retry. c010 is -now braked at resident revision 372 with no active lease. The next live gap is -coordination, not transport: status still says `regatherManually` because the -historical Reorientation result failed, but Heartbeat/Self have no typed Eyes -or Reorientation pressure. Map that owner before adding any route. - -Source inspection closes that apparent gap as an intentional authority -boundary. `apply_manual_regather_approval` accepts only a current Self-derived -`regatherManually` action and produces one `launchResearch` only when the -coordinator receives explicit `--approve-manual-regather`. Resident safe -continuation deliberately excludes this action; Heartbeat's reorientation role -label is display derivation, not grant authority. Operator owns approval, Self -owns the recommendation, and Heartbeat schedules only typed pressure. Generic -operator objective text cannot impersonate approval. c010 is therefore -correctly alive, idle, and braked at revision 372. Continue retention, -supervisor/log ownership, and endurance. A live regather is a separate operator -decision or a future mapped typed operator-ingress cut. - -## Resident PID 1 worker reaping cut — 2026-08-11 - -Live c010 process inspection found six defunct `epiphany-model-*` processes -adopted by resident `epiphany-swarm` PID 1. Runtime and artifact retention were -bounded, but the operating-system child lifecycle was not. Exact `465af24d` -makes resident Self enumerate typed runtime worker process claims and call -exact `waitpid(pid, WNOHANG)` for those claimed PIDs before every once/serve -cycle and before retention. It does not use process-name discovery or -`waitpid(-1)`, and it cannot steal the known coordinator children still owned -by `NativePorts` `Child` handles. Reaping mutates no CultCache authority. - -Six focused Windows process-observation tests and all nine swarm tests pass. -The Unix-only exact-child test passed 1/1 on Starfire. Exact release -`sha256-089e000511f0420bfaab1136952b8cf94677a72d5c30a3fb3e6a26996bd3726f` -with witness -`sha256-20ca293589b33d3b2e6ea5a7411db544741fe18360ecbd4423cdfa000d1ad7c6` -contains 24 authenticated binaries and no build warnings. Receipts are under -`.epiphany-run/forge-crosscommit-465af24d`; the container named -`epiphany-linux-package-465af24d-rejected-stale-source` is a sealed rejected -attempt that packaged d3 after a checkout syntax failure and was never -published. - -c010 Heartbeat and Self stopped by SIGTERM at exit zero. c011 runs the exact -465 package on the same named state/workspace/Codex volumes, is braked at -resident revision 372, and has no active lease or defunct child. One manual -regather attempt and one replacement objective attempt both failed closed -before worker launch: the current action is `awaitFrontierProposal`, terminal -sessions cannot be reused, and immutable typed objective intake cannot be -substituted. Do not manufacture a claim to satisfy the smoke. The remaining -acceptance gate is the next genuine packaged worker lifecycle: after normal -terminalization, resident PID 1 must return to zero zombies. Keep c011 braked -until such typed work exists. - -That live gate is now accepted. Explicit operator proposal -`operator-c011-worker-reaper-live-proof-20260811` atomically selected Modeling -request -`repo-frontier-proposal-modeling-1c15a1d0d22e52cff8d735f331658c6a9a652b183d29f35902a7ca6dbc676f50`. -After release, Heartbeat issued exactly one grant and Self launched the exact -packaged coordinator. Model worker PID 152 became a running child of resident -PID 1 after the coordinator exited. It completed authenticated Modeling, -resident Self held `awaiting-fulfillment`, then settled the grant at revision -376. On the next cycle PID 152 was absent from the process table rather than -defunct; resident PID 1 was the only resident process. This is the required -source-to-package-to-kernel proof for the reaper owner. - -The native review continuation then completed and was acknowledged. Heartbeat -issued the next typed admitted-model-direction Imagination grant at pulse 216; -the canonical brake engaged before a new worker launch. c011 is braked at -revision 381 with no active lease and zero zombies. Preserve that exact next -grant/request binding; inspect it before release, then run one bounded -Imagination lifecycle and require zero zombies again. Do not create another -proposal or manual-regather pressure. - -The preserved Imagination grant was then released without creating new -pressure. Exact admitted-direction request -`c72af0e16fbc767966e63f56f058ae3741f07d2af4b12bab7b65dd8d8fab4bbb` -launched packaged worker PID 275 as another adopted child of resident PID 1. -It terminalized normally, Self settled once at revision 384, and the following -cycle again returned the resident process table to PID 1 alone with no defunct -child. Heartbeat resumed routine physiology and no new admitted work appeared. -The brake is engaged at revision 384. The reaper cut is accepted across both a -proposal Modeling worker and an admitted-direction Imagination worker. +Updated: 2026-08-12 + +## Current state + +The five-day live shakedown campaign is paused for architectural consolidation. +The source branch is `codex/epiphany-shakedown-live`; the last pushed source +before surgery is `80541843`. The working tree contains the consolidation cut +described below and must be committed only after final source checks and map +updates. + +The accepted live body remains c011 at exact `465af24d` on Starfire, cognitively +braked at resident revision 384 with no active lease, admitted work, or defunct +children. Do not replace it during consolidation. Yggdrasil remains the public +crossing and never builds Epiphany. + +## Consolidation cut + +The shakedown found the same missing invariants across several request families. +This pass generalizes those invariants instead of continuing family-specific +repair. + +- `causal_work_identity` is the single pure derivation owner for Proposal + Modeling, Research, frontier Planning, PlanMind, and Admitted Model Direction + request identities. Runtime plus immutable admitted cause determine identity. + Coordinator thread and timestamps are provenance only. +- Coordinator launch cannot restore a superseded request thread into canonical + state. The current admitted thread owns transport; the request's creation + thread remains inspectable provenance. +- `ImmutableGithubSource` is the single parser, validator, canonicalizer, and + renderer for immutable public GitHub identities. Modeling selection, Eyes + execution, and Mind receipt authentication use the same type. +- Mind now independently rejects a malformed but internally self-consistent + public-source receipt. Provider validation is no longer trusted as a substitute + for admission validation. + +The full `epiphany-core` library passes 683 tests with one intentional ignored +cross-process helper. `epiphany-tool-mcp-runtime` passes 14 tests with one +intentional ignored live-network proof. Focused stale-thread refusal preserves +the exact store bytes. + +## Authority map + +- Owner: causal work identity owns deterministic request identity. +- Inputs: runtime identity plus the immutable proposal, admitted model/frontier, + accepted result, candidate digest, or admission receipt appropriate to the + explicit request family. +- Outputs: deterministic typed request IDs. +- Derived state: creation thread and timestamps are provenance; job, process, + grant, model execution, and tool IDs own attempts beneath the request. +- Forbidden writers: current coordinator thread, resident projection, launch + callback, retry loop, and worker output cannot fork or repair request identity. +- Shared paths: direct and resident launches consume the same derived identity; + current admitted thread carries the launch without rewriting request provenance. +- Cut line: family-local hash formulas, current-thread selection gates, and + downstream thread-restoration behavior are removed or demoted. + +- Owner: immutable public-source identity owns GitHub identity grammar and + canonical rendering. +- Inputs: owner, repository, exact 40-hex commit, and bounded repository path. +- Outputs: canonical lowercase revision, repository ref, and source ref. +- Derived state: provider URL and receipt display fields. +- Forbidden writers: tool output and mutually consistent JSON strings cannot + define source identity. +- Shared paths: Modeling, Eyes, and Mind call the same typed owner. +- Cut line: the runtime composite parser and provider-local validators are gone. + +## Deliberately separate lifecycle authorities + +Do not collapse these into one enum or service: + +- Heartbeat schedules and consumes acknowledgements. +- Resident Self owns grants, leases, cooldown, cancellation, and requeue. +- Coordinator owns one process incarnation and its terminal receipt. +- Runtime worker attempt owns launch, exact process claim, result, and archive. +- Mind decides adoption; fulfillment is evidence, not admission. + +The next physical extraction is a narrow `runtime_worker_attempt` module. It +should centralize typed process-status predicates and typed-request association +without merging the authorities above or introducing a registry. + +## Acceptance gates before shakedown resumes + +1. Extract the worker-attempt aggregate from `runtime_spine` with no schema or + state migration. +2. Replay full core, resident, coordinator, tool-runtime, and OpenAI-runtime + suites after extraction. +3. Prove immutable public Eyes success and no-grant denial on a copied packaged + body. This is the paused shakedown's first remaining live gate, not part of + the consolidation commit. +4. Run one fresh-repository source -> Hands -> Soul -> Modeling -> Mind -> Self + capstone before claiming organism-level readiness. + +## Immediate next action + +Review the current diff for any surviving family-local causal hash or public +GitHub parser. Commit and push this first consolidation cut. Then map and extract +`runtime_worker_attempt`; do not add new capability surfaces and do not replace +c011. diff --git a/notes/perfect-machine-audit-roadmap.md b/notes/perfect-machine-audit-roadmap.md index eced7b49..dbf36fcd 100644 --- a/notes/perfect-machine-audit-roadmap.md +++ b/notes/perfect-machine-audit-roadmap.md @@ -1,145 +1,62 @@ # Perfect Machine audit roadmap -Updated: 2026-08-11 +Updated: 2026-08-12 -## Objective +## Operating state -Prove every Epiphany faculty both at its own authority boundary and in live -coordination before treating the organism as deployment-ready. Tests prove only -the seam they observe. Packaged Linux bodies, copied-state falsification, and -the actual braked resident body are the live gates. +The live shakedown is paused for architectural consolidation. Source development +continues on `codex/epiphany-shakedown-live`; accepted live c011 remains exact +`465af24d` on Starfire, braked at revision 384 with no active lease, admitted +work, or defunct children. Yggdrasil is the public crossing, never the forge. -## Current body +No new capability surface or live-body replacement is authorized until the +consolidation gates below close. -- Source branch: `codex/epiphany-shakedown-live`. -- Current pushed source: exact `8fb61ac2`. -- Accepted live runtime implementation: exact `465af24d` through resident PID 1 - reaping across genuine Modeling and Imagination worker families. -- Audited/live release: - `sha256-089e000511f0420bfaab1136952b8cf94677a72d5c30a3fb3e6a26996bd3726f`; - witness - `sha256-20ca293589b33d3b2e6ea5a7411db544741fe18360ecbd4423cdfa000d1ad7c6`. -- Actual c011: both owners are alive under the engaged cognitive brake at - resident revision 384, with no active lease, no admitted work, and zero - defunct children. Exact claimed worker PIDs 152 and 275 terminalized through - Modeling and Imagination respectively, settled once, and were reaped by the - resident PID 1 owner. -- Build body: Starfire. Yggdrasil is the small public crossing and never builds - this graph. +## Architectural consolidation -## Live authority matrix - -| Faculty | Owner | Accepted proof | Remaining live gate | +| Invariant | Owner | Current evidence | Remaining gate | |---|---|---|---| -| Self | resident Self state machine | single-consumption Heartbeat grants, typed fulfillment, exact recovery/requeue, cooldown and brake behavior; actual c007h superseded one overtaken unlaunched continuation and accepted the recovered proposal-Modeling result exactly once | autonomous turnover from a genuinely new typed frontier; current `awaitFrontierProposal` is correctly idle | -| Substrate Gate | `substrate_gate` | immutable scoped grants now bind every advertised Eyes, Modeling, and Soul source operation through the outer worker launch; canonical brake covers direct daemon lifecycle actuation; non-repository process utilities retain explicit owners | packaged negative proof that an ungranted public request creates no network consequence | -| Eyes | Eyes gateway and authenticated source tools | challenged-claim Windows circuit, governed Linux tool circuit, and exact immutable GitHub reader with typed receipt derivation | package and adopt one broader public source through Eyes into Mind | -| Modeling | runtime-owned typed Modeling contracts | causal Eyes-to-Modeling acceptance, direct proposal Modeling, archived fulfillment | broader Body-map coverage across a changing live repository | -| Imagination | typed proposal/consideration producers | genuine packaged multi-option generation, proposal-only candidates, exact fulfillment, no Hands adoption leak | autonomous turnover from the next genuine eligible frontier | -| Hands | Hands gateway | bounded patch, command, commit, push, and changed-path receipts; Idunn, crossing, forge, IDE, repo-birth, and model-runtime processes retain separate owners; Unity method override is structurally refused | audit the next Soul verifier boundary rather than adding Hands gates around non-Hands owners | -| Soul | Soul gateway | consequence-bound verdict, causal Modeling route, retention and replay | collapse remaining verifier-specific broad projections into narrow receipt reads | -| Mind | canonical transactions and specialized admission | atomic RepoModel admission, launch-owned adjudication, semantic/runtime retention | audit remaining state families for legacy writers and run longer memory behavior | -| Persona | Persona turn, speech audit, public mouth | cross-host request/permit/receipt, signed failure and unknown no-repost behavior, conversation retention | one completed public consequence; currently blocked by absent Yggdrasil Discord credential | -| Continuity | runtime/resident recovery and retention | graceful shutdown, exact process-death recovery, session closure/archive, lifecycle retention, non-resurrection, bounded endurance, and receipt-derived recovery on the current body | later deployed restart supervision | -| Nervous system | Heartbeat, runtime spine, Idunn, CultMesh | detached scheduling, typed jobs, provider readiness, active/warming transitions across PID namespaces, bounded endurance, narrow local-Verse decision reads, bounded Docker logs, and causal grant turnover | audit non-repository actuator publication and command ownership | -| Body | Rust binaries, named-volume CultCache stores, model transport | deterministic 24-binary packaging, fast warm replay, named-volume interruption proof, and exact PID 1 reaping across two adopted worker kinds | deployment-sized endurance and remaining inspection surfaces | +| Durable request identity excludes mutable transport provenance | `causal_work_identity` | Proposal Modeling, Research, Planning, PlanMind, and Admitted Model Direction use one pure derivation owner; stale thread restoration refuses byte-identically | replay packaged coordinated circuits after worker-attempt extraction | +| Immutable GitHub identity has one grammar | `ImmutableGithubSource` | Modeling selection, Eyes execution, and Mind authentication share one parser/canonicalizer; malformed identities fail at Mind | copied packaged public success and no-grant denial | +| One worker attempt has one process/result/archive authority | planned `runtime_worker_attempt` | current lifecycle and archive proofs remain accepted | extract typed status predicates and request association from `runtime_spine` without schema migration | +| Canonical state admission has one writer | coordinator state transaction / Mind | CAS companions and negative source guards accepted | continue legacy-writer audit only when source evidence finds a live seam | -## Accepted coordinated circuits +## Worker-attempt extraction boundary -1. Substrate Gate -> Eyes -> Mind evidence admission. -2. Heartbeat -> Self -> coordinator -> runtime worker -> typed fulfillment -> - exact resident settlement. -3. Eyes acceptance -> causal Modeling launch -> Modeling acceptance -> route - consumption. -4. Imagination proposal -> Modeling -> Mind admission -> new direction pressure, - without accidental Hands authority. -5. Hands consequence -> Soul verdict -> Modeling update -> Mind transaction. -6. Process death -> Continuity recovery -> canonical requeue or fulfilled - settlement -> archive/retention without resurrection. -7. Persona feedback crossing -> bounded consideration -> speech audit -> signed - permit/refusal/no-repost boundary. +- Owner: `runtime_worker_attempt` owns immutable launch, exact process claim, + semantic result terminality, authenticated fulfillment, and archive tombstone. +- Inputs: typed launch, runtime job, exact process identity/activation token, + semantic result, exact OS observation, Mind admission evidence, and the + resident-live request set. +- Outputs: typed attempt projection, allowed transitions, fulfillment evidence, + and failed/fulfilled tombstones. +- Derived state: runtime job/result/event are audit projections; resident + grant/ack are scheduling projections; coordinator receipt closes an + incarnation. None independently owns attempt success. +- Forbidden writers: Heartbeat, coordinator receipt, generic job status, + process liveness without exact identity, retention, and archived tombstones + cannot synthesize semantic fulfillment. +- Cut line: remove process-status string matching and repeated typed-request + family arrays from `runtime_spine`, `resident_self`, and `coordinator_launch`. + Do not merge stores or create a universal lifecycle service. -## Accepted endurance and current-body recovery +## Shakedown acceptance matrix -Historical c006 completed the detached plateau from iteration 572 to -1496. Thirty samples observed a 923-pulse delta with zero authority violations, -exact-zero state/workspace growth, Heartbeat RSS 28.63-28.88 MiB, resident RSS -54.11-55.50 MiB, both role owners alive, and final authenticated readiness -`active` under the engaged brake. Receipts: -`.epiphany-run/c006-endurance-16407f7e`. +| Circuit | Positive | Negative | Timeline/restart | Status | +|---|---|---|---|---| +| Heartbeat -> Self -> coordinator -> worker -> settlement | packaged genuine workers | no dual grant/process authority | endurance, SIGTERM, restart, receipt-order skew | accepted on c011 ancestry | +| Eyes immutable public source -> Mind | provider source proof and source tests | malformed identity rejected by Mind; missing grant source test | copied packaged success/denial pair | source complete, live gate open | +| Proposal/Planning causal identity | deterministic shared owner | stale carrier cannot restore thread | cross-incarnation replay | source complete | +| Hands -> Soul -> Modeling -> Mind -> Self | bounded adjacent circuits | bypass/substitution refusals | fresh-repository full loop | capstone open | +| Persona -> Bifrost -> public consequence | signed failure/unknown/no-repost | private-state and permit refusal | successful receipted consequence | blocked by external credential | +| Worker process -> result/death -> archive | genuine Linux workers and zero-zombie reaping | resurrection and competing retry refused | both receipt orderings and restart | accepted; physical extraction pending | +| Eve/CultUI operator interface | typed state surfaces | renderer cannot own truth | load/transition/settled/re-entry probes | open | -Exact `c9a2a979` then completed two consecutive receipt-bound causal grants on -actual c006. The first performed one exact Modeling failure-review supersession; -the second refused stale action before consequence and settled on -`awaitFrontierProposal`. Both grants terminalized, resident state returned idle -at revision 34, protected consequence families stayed byte-identical, and the -cognitive brake was re-engaged. Receipts: -`.epiphany-run/c006-continuation-c9a2a979`. +## Immediate order -Actual c007h runs exact `3a5d2b5e`. It atomically superseded the preserved -unlaunched `launchModeling` continuation without starting a process, issued the -recovered `reviewModelingResult` route, accepted -`result-worker-8ddf57c1-96b4-4a60-ae8b-b24404e9ce2f` exactly once, and returned -to idle at revision 312. The cognitive brake is engaged; no pending proposal, -Imagination frontier, active lease, or Hands consequence exists. - -Exact candidate `3fdff19f` retains `daemon.lifecycle_poke` whenever the -canonical all-scope brake is engaged. Its 24-binary Linux release completed in -30.66s; an identical warm replay took 0.82s. The packaged Verse smoke passes. -A forced supervisor reconciliation with operator-supplied `/bin/sh` against -quarantined copied state refused exit 1, preserved the exact CultCache hash, -and created no command marker. Receipts: -`.epiphany-run/forge-crosscommit-3fdff19f*` and -`.epiphany-run/brake-actuator-proof-3fdff19f`. - -## Completed narrow local Verse consumer audit - -Lifecycle and single-target commands read only the state families that own -their decisions. Managed-task install/control, generic service-runbook -construction, and repo-work service audit read only the canonical brake. -Single-daemon restart-policy writing reads exact daemon status. Direct -reconciliation reads exact status, exact policy, and brake. Single-target -`poke-daemon` reads exact status, brake, topology-family display metadata, and -its exact written intent. - -Every surviving production aggregate context read has an aggregate output: - -| Consumer | Why the aggregate is owned | -|---|---| -| coordinator launch context | assembles the bounded multi-organ prompt packet | -| supervisor scheduler tick | enumerates restart policies, daemon statuses, and brake scope | -| cluster daemon runbook | enumerates topology and matching status rows | -| `seed` and `query` | explicitly emit the complete local Verse projection | -| receipt directory | joins several receipt families into one operator report | -| bulk poke and swarm triage | enumerate non-ready daemons and topology | -| quarantined smokes/tests | falsify the aggregate projection itself without production authority | - -No remaining single-family decision reads the full context. Do not decompose -these legitimate aggregates into ad hoc query piles. - -## Selected next bounded cut - -Keep c011 alive and braked. Source now binds every governed model-derived tool -intent to its outer worker launch and exact Substrate Gate grant. Eyes alone can -see the bounded `github_file` provider, which accepts only one GitHub repository, -exact 40-hex commit, repository path, 64 KiB UTF-8 body, no redirects, and no -proxy. Runtime recomputes its identity and bytes before a typed -`EyesSourceLookupReceipt` can share the Mind acceptance transaction. Focused -hostile substitution is byte-identical and the exact upstream README reader is -already proven from Starfire. - -Package this source once on Starfire. On copied named-volume state, launch an -actual Research lane that cites the returned `sourceRef` and -`evidenceReceiptId`, accept it into Mind, and inspect the typed lookup plus Eyes -packet in the committed snapshot. Then exercise an otherwise exact worker whose -grant lacks `publicSourceRead`; require refusal before adapter/network execution -and byte-identical runtime state. Only after both gates pass may c011 be replaced. -Generic MCP transport remains transport and arbitrary URL fetching remains -absent. Do not build on Yggdrasil. - -## Completion standard - -The shakedown is complete only when every matrix row has current authoritative -evidence, every explicit remaining gate is either proven or recorded as an -operator-owned external dependency, the live coordinated circuit survives -endurance and restart, and no stale roadmap claim is being mistaken for state. +1. Commit and push the causal/public-source identity consolidation. +2. Extract `runtime_worker_attempt` without changing persisted contracts. +3. Replay source tests and the accepted worker settlement/archive circuits. +4. Resume shakedown with the packaged public Eyes success/denial pair. +5. Run the fresh-repository full-organ capstone before any deployment-ready + claim. diff --git a/state/ledgers.msgpack b/state/ledgers.msgpack index bb2c72fc8d179fe2aaa8540cf438675e4163482e..e706ee9b68927c1cd9ce54f11fb00ee69172e9d6 100644 GIT binary patch delta 526 zcmYjNO=}cE5Or2#l8Xl+$3TJPwjbHu5JCb0(GYS7Eb7Ty?Q~_gO;6RNy2r3y_Ta%E zp!*vFISC$uf55Z&13c)T@Mz5}Bssk9rutRA_v+v8tzUn(zHVes2E+ZG;r?Lw_Q!+u zviI#-c9CUQ9~Z4pi&kc+?}vs*h84qO!>VEJX3<*z8=ijoKG+`YcDDCA{r;O~*5{vx zoAc`tR*@XUDV~#)ONLxHO7ISo7lsKjDF*++IJr?VfYL=pF@bl)$)_1$t`Z}RR7$A{ zr{XAhp0wc=MMBM|Z5Rb)Zff=G)U#^?vYW$mSNN1{dea3jy;5E)A3&Nap#vYGRC!N~ zoD&EK6J#@-FpybN^`z!0Cefv3YZ%WGb(a2e4A!A^R>$nZNl{b@$AON0npWfaYpK-6 zvRs0NkGI}?M>C4O+UH%)iDFTpHuB3Kc2trboEnXHW<5fI;Y_r!NEU^BdAli3u?sIm j33m5}P-2YKb-h0L30u)wVi8+!Wm_!>`a4U?Jx2FGqd&a5 delta 72 zcmccgNcG1()eWMIdD`{GA?VL%G5rUi4llFG&2yh05K~N RvjH(X5OZvw%Eb9N2LNT%7WM!D diff --git a/state/map.yaml b/state/map.yaml index 71bbbd51..bb48c9a6 100644 --- a/state/map.yaml +++ b/state/map.yaml @@ -4,7 +4,7 @@ experiment: purpose: Native, inspectable agent organism with typed state and explicit organ authority. objective: - current: Prove every Epiphany organ individually and in live coordination on the shakedown branch before treating the organism as deployment-ready. + current: Consolidate the architecture exposed by the paused five-day shakedown before any new capability or live-body replacement. architecture: body: Repository, runtime, service processes, stores, interfaces, and deployment substrate. @@ -38,7 +38,7 @@ 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, exact eea15e82 model-turn JSON ingress, exact b1e8c89a semantic unattempted-generation retention, exact 6bc3ec3f semantic physical-epoch retirement, and exact 44230a05 Persona conversation retention are proven. Gamecult-ops 059821f owns Yggdrasil stream retention and exact 6ee08a4 owns stable Starfire Persona-permit firewall ingress. Exact 16c4b19f genuine idle and exact a987d2f7 active cognition completed 900-pulse bounded plateaus. Runtime-owned typed fulfillment is accepted live under exact 6dd9b132. Yggdrasil is the small public crossing body, never the release forge. latest_phase: Live c010 inspection found six defunct model-worker grandchildren adopted by resident PID 1. Exact 465af24d makes resident Self enumerate typed runtime worker process claims and call exact nonblocking waitpid only for those claimed PIDs before each once/serve cycle and before retention. Coordinator Child handles remain separately owned. Six Windows process tests, nine swarm tests, and the Unix exact-child test pass. The warning-free 24-binary Linux release sha256-089e000511f0420bfaab1136952b8cf94677a72d5c30a3fb3e6a26996bd3726f with witness sha256-20ca293589b33d3b2e6ea5a7411db544741fe18360ecbd4423cdfa000d1ad7c6 is live as c011. A typed operator proposal drove exact Modeling request repo-frontier-proposal-modeling-1c15a1d0d22e52cff8d735f331658c6a9a652b183d29f35902a7ca6dbc676f50 through Heartbeat, Self, coordinator, adopted worker PID 152, terminal fulfillment, settlement, and zero-zombie reaping. Its authenticated review continuation completed and emitted admitted-direction Imagination request c72af0e16fbc767966e63f56f058ae3741f07d2af4b12bab7b65dd8d8fab4bbb. That preserved grant then launched adopted worker PID 275; it terminalized normally, settled at revision 384, and was reaped with PID 1 again returning to zero defunct children. It produced no further admitted work. c011 is braked at revision 384 with no active lease. The reaper cut is accepted across two genuine worker kinds. Yggdrasil never builds. operational_state: - local_worktree: frontier_owned_research_identity_and_typed_public_source_target_tests_green_pending_commit_package_live_proof + local_worktree: causal_identity_and_immutable_public_source_owners_generalized_tests_green_pending_commit operator_wireguard: restored starfire_persona_permit_firewall: persistent_exact_gamecult_ops_6ee08a4 yggdrasil: canonical_small_public_crossing_body @@ -70,7 +70,7 @@ current_status: yggdrasil_epiphany_service_contract: repaired_in_gamecult_ops_812b427_not_installed resident_physiology: c011_exact_465af24d_alive_braked_revision384_after_modeling_and_imagination_terminal_settlement_and_zero_zombie_reaping unresolved_authority: Coordinator receipt, Heartbeat pulse-artifact, genuine-idle and active resource plateaus, exact-grant terminality, restart-persistent cooldown refusal, schedule/action issuance cardinality, runtime-owned typed fulfillment, all three packaged fulfilled-before-receipt lanes, genuine packaged Imagination option generation, narrow model-generation retention, published model-turn JSON ingress, semantic logical/physical retention, Persona conversation retention, stable Starfire firewall ownership, completed model-adapter session archival, normal coordinator lifecycle opening/error closure/legacy repair/archival, co-resident resident lifecycle retention, authenticated outer-worker attempt retention, deployed supervisor/projector journald ownership, Docker named-volume atomic snapshot visibility, deterministic incremental release construction, and canonical-brake refusal of direct daemon lifecycle actuation are accepted. Starfire's Docker Desktop F: bind is rejected for mutable authority after an exact packaged lockless reader observed an empty published snapshot during writer interruption. Historical migrated semantic attempts without recorded physical namespace remain durable and non-retirable. One completed Discord consequence remains blocked by the absent Yggdrasil credential. Exact aa841873 also makes legacy coordinator repair one full-snapshot transaction so a later hostile family cannot leave an earlier partial repair. - next_action: Keep exact c011 alive and cognitively braked. Copied-state d7 replay launched and accepted Research, but the packet remained uncovered because mutable coordinator thread state invalidated the frontier-owned request; its launch also lacked a typed immutable public target and therefore inspected only local scope. Commit and package the corrected owner cut: request identity derives from runtime plus admitted model/frontier, thread is creation provenance only, and strict immutable GitHub refs flow from Modeling-owned frontier evidence into the exact Research context. Replay on fresh copied c011 state, accept one immutable public Research lookup through Eyes into Mind, then prove an otherwise exact request without publicSourceRead refuses before adapter or network consequence with byte-identical state. Only then replace c011. Do not build on Yggdrasil. + next_action: Keep exact c011 alive and cognitively braked. Commit and push the generalized causal-work and immutable-public-source identity owners after final source review. Then extract the narrow runtime_worker_attempt aggregate: typed process-status predicates and request-family association only, without merging Heartbeat, resident, coordinator, runtime-job, OS-process, or Mind authority. Replay accepted source tests before resuming the packaged public Eyes gates. Do not build on Yggdrasil. active_subgoals: - Prove Persona, Self, Eyes, Modeling, Imagination, Hands, Soul, Mind, Continuity, and nervous-system behavior individually.