Consolidate causal identity ownership

This commit is contained in:
Meta Vens 2026-08-12 01:44:00 +02:00
commit 868a5be070
12 changed files with 494 additions and 4445 deletions

View file

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

View file

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

View file

@ -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::EpiphanyThreadStateEntry>(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::<EpiphanyRuntimeIdentity>(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::EpiphanyThreadStateEntry>(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::EpiphanyThreadStateEntry>(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::<EpiphanyThreadStateEntry>(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::<RepoFrontierProposalModelingLaunchBinding>(
"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)?;

View file

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

View file

@ -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<Self> {
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<Self> {
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}"
);
}
}
}

View file

@ -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::EpiphanyThreadStateEntry>(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::EpiphanyThreadStateEntry>(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::<RepoFrontierProposalModelingRequest>()?;
@ -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::<RepoFrontierPlanDecisionReceipt>()?
.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::<Vec<_>>();
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::<Vec<_>>();
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::<RepoModelAdmissionReceipt>()?
.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)?;

View file

@ -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<Value> {
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]

View file

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

File diff suppressed because it is too large Load diff

View file

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

Binary file not shown.

View file

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