From 795b231e61663febf6bf66ec4f4ac8f62717a00c Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Fri, 29 May 2026 00:09:40 +0100 Subject: [PATCH] Make continuity a protocol instead of Life --- epiphany-core/src/agent_memory.rs | 1 - .../src/bin/epiphany-cultmesh-smoke.rs | 4 +- .../src/bin/epiphany-mvp-coordinator.rs | 2 +- .../src/bin/epiphany-repo-personality.rs | 6 - epiphany-core/src/continuity_gateway.rs | 140 ++++++++++++++++++ epiphany-core/src/cultmesh_integration.rs | 42 +++--- epiphany-core/src/eyes_gateway.rs | 2 +- epiphany-core/src/face_turn.rs | 5 +- .../src/heartbeat_state/heartbeat_roles.rs | 7 - epiphany-core/src/lib.rs | 14 +- epiphany-core/src/life_gateway.rs | 140 ------------------ epiphany-core/src/organ_dependencies.rs | 17 +-- .../src/prompts/epiphany_specialists.toml | 16 +- .../src/prompts/repo_memory_distiller.md | 2 +- .../src/prompts/repo_personality_distiller.md | 4 +- .../src/prompts/repo_trajectory_distiller.md | 2 +- epiphany-core/src/runtime_spine.rs | 44 +++--- epiphany-core/src/surfaces/role_result.rs | 54 +++++-- .../src/prompts/epiphany_doctrine.md | 4 +- ...cts.md => continuity-cultnet-contracts.md} | 30 ++-- notes/epiphany-current-algorithmic-map.md | 4 +- notes/epiphany-distilled-agent-doctrine.md | 4 +- notes/epiphany-fork-implementation-plan.md | 4 +- notes/epiphany-planning-substrate.md | 2 +- notes/eyes-cultnet-contracts.md | 2 +- notes/fresh-workspace-handoff.md | 22 +-- notes/organ-dependency-contracts.md | 8 +- notes/perfect-machine-audit-roadmap.md | 40 ++--- .../repo-personality-projection-layer-plan.md | 14 +- notes/soul-cultnet-contracts.md | 2 +- ...piphany-memory-migration-sandbox-prompt.md | 8 +- schemas/agent-state-variable-glossary.md | 2 +- schemas/canonical-agent-state-schema.md | 5 +- schemas/dossier-profiles.md | 1 - state/ledgers.msgpack | Bin 164681 -> 165113 bytes state/map.yaml | 24 +-- 36 files changed, 342 insertions(+), 336 deletions(-) create mode 100644 epiphany-core/src/continuity_gateway.rs delete mode 100644 epiphany-core/src/life_gateway.rs rename notes/{life-cultnet-contracts.md => continuity-cultnet-contracts.md} (50%) diff --git a/epiphany-core/src/agent_memory.rs b/epiphany-core/src/agent_memory.rs index c22cc6b1..ff6a680d 100644 --- a/epiphany-core/src/agent_memory.rs +++ b/epiphany-core/src/agent_memory.rs @@ -27,7 +27,6 @@ const ROLE_TARGETS: &[(&str, &str, &str)] = &[ ), ("verification", "epiphany.soul", "soul.agent-state.json"), ("implementation", "epiphany.hands", "hands.agent-state.json"), - ("reorientation", "epiphany.life", "life.agent-state.json"), ("research", "epiphany.eyes", "eyes.agent-state.json"), ("face", "epiphany.face", "face.agent-state.json"), ("coordinator", "epiphany.self", "self.agent-state.json"), diff --git a/epiphany-core/src/bin/epiphany-cultmesh-smoke.rs b/epiphany-core/src/bin/epiphany-cultmesh-smoke.rs index 0819ed76..13c1f5f0 100644 --- a/epiphany-core/src/bin/epiphany-cultmesh-smoke.rs +++ b/epiphany-core/src/bin/epiphany-cultmesh-smoke.rs @@ -11,7 +11,7 @@ use epiphany_core::load_latest_epiphany_cultmesh_operator_snapshot; use epiphany_core::write_epiphany_cultmesh_eyes_contracts; use epiphany_core::write_epiphany_cultmesh_global_room_policies; use epiphany_core::write_epiphany_cultmesh_hands_contracts; -use epiphany_core::write_epiphany_cultmesh_life_contracts; +use epiphany_core::write_epiphany_cultmesh_continuity_contracts; use epiphany_core::write_epiphany_cultmesh_mind_contracts; use epiphany_core::write_epiphany_cultmesh_operator_snapshot; use epiphany_core::write_epiphany_cultmesh_operator_status; @@ -44,7 +44,7 @@ fn main() -> Result<()> { write_epiphany_cultmesh_eyes_contracts(&store, "epiphany-cultmesh-smoke")?; write_epiphany_cultmesh_hands_contracts(&store, "epiphany-cultmesh-smoke")?; write_epiphany_cultmesh_soul_contracts(&store, "epiphany-cultmesh-smoke")?; - write_epiphany_cultmesh_life_contracts(&store, "epiphany-cultmesh-smoke")?; + write_epiphany_cultmesh_continuity_contracts(&store, "epiphany-cultmesh-smoke")?; let operator_status = default_epiphany_cultmesh_operator_status( "epiphany-cultmesh-smoke", "2026-05-27T00:00:00Z", diff --git a/epiphany-core/src/bin/epiphany-mvp-coordinator.rs b/epiphany-core/src/bin/epiphany-mvp-coordinator.rs index 27afb1c6..7142d9a7 100644 --- a/epiphany-core/src/bin/epiphany-mvp-coordinator.rs +++ b/epiphany-core/src/bin/epiphany-mvp-coordinator.rs @@ -1140,7 +1140,7 @@ fn local_mvp_checkpoint_patch(cwd: &Path, objective: Option<&str>) -> Value { { "id": "local-mvp-runner", "title": "Local MVP runner", - "purpose": "One local operator cycle that enters through Face, runs coordinator-owned work, and invokes Life/heartbeat sleep afterward.", + "purpose": "One local operator cycle that enters through Face, runs coordinator-owned work, and invokes Continuity/heartbeat sleep afterward.", "code_refs": local_refs, }, { diff --git a/epiphany-core/src/bin/epiphany-repo-personality.rs b/epiphany-core/src/bin/epiphany-repo-personality.rs index 36077e4c..2ad4740f 100644 --- a/epiphany-core/src/bin/epiphany-repo-personality.rs +++ b/epiphany-core/src/bin/epiphany-repo-personality.rs @@ -57,7 +57,6 @@ const ROLES: &[&str] = &[ "modeling", "implementation", "verification", - "reorientation", ]; const AXES: &[&str] = &[ @@ -2234,7 +2233,6 @@ fn role_id_for_agent_id(agent_id: &str) -> Option<&'static str> { "epiphany.proprioception" => Some("modeling"), "epiphany.hands" => Some("implementation"), "epiphany.soul" => Some("verification"), - "epiphany.life" => Some("reorientation"), _ => None, } } @@ -2442,9 +2440,6 @@ fn memory_role_filter(role_id: &str) -> &'static str { "verification" => { "Distill tests, smoke commands, evidence standards, invariants, user-facing truth checks, and what Soul should refuse to bless." } - "reorientation" => { - "Distill compaction, scratch, checkpoint, sleep, heartbeat, and continuity doctrine that Life must preserve across rupture." - } _ => "Distill only durable role-relevant memory with source refs and uncertainty.", } } @@ -3952,7 +3947,6 @@ fn role_display(role_id: &str) -> &'static str { "modeling" => "Proprioception", "implementation" => "Hands", "verification" => "Soul", - "reorientation" => "Life", _ => "Lane", } } diff --git a/epiphany-core/src/continuity_gateway.rs b/epiphany-core/src/continuity_gateway.rs new file mode 100644 index 00000000..d2991aa0 --- /dev/null +++ b/epiphany-core/src/continuity_gateway.rs @@ -0,0 +1,140 @@ +use serde::Deserialize; +use serde::Serialize; + +pub const CONTINUITY_PACKET_TYPE: &str = "epiphany.continuity.packet"; +pub const CONTINUITY_COMPACTION_CHECKPOINT_TYPE: &str = "epiphany.continuity.compaction_checkpoint"; +pub const CONTINUITY_SLEEP_DISTILLATION_TYPE: &str = "epiphany.continuity.sleep_distillation"; +pub const CONTINUITY_RECOVERY_RECEIPT_TYPE: &str = "epiphany.continuity.recovery_receipt"; +pub const CONTINUITY_STALE_TURN_REPAIR_TYPE: &str = "epiphany.continuity.stale_turn_repair"; +pub const CONTINUITY_REFUSAL_RECEIPT_TYPE: &str = "epiphany.continuity.refusal_receipt"; +pub const CONTINUITY_PACKET_SCHEMA_VERSION: &str = "epiphany.continuity.packet.v0"; +pub const CONTINUITY_COMPACTION_CHECKPOINT_SCHEMA_VERSION: &str = + "epiphany.continuity.compaction_checkpoint.v0"; +pub const CONTINUITY_SLEEP_DISTILLATION_SCHEMA_VERSION: &str = "epiphany.continuity.sleep_distillation.v0"; +pub const CONTINUITY_RECOVERY_RECEIPT_SCHEMA_VERSION: &str = "epiphany.continuity.recovery_receipt.v0"; +pub const CONTINUITY_STALE_TURN_REPAIR_SCHEMA_VERSION: &str = "epiphany.continuity.stale_turn_repair.v0"; +pub const CONTINUITY_REFUSAL_RECEIPT_SCHEMA_VERSION: &str = + "epiphany.continuity.refusal_receipt.v0"; + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct ContinuityCultNetContract { + pub contract_id: String, + pub verse_id: String, + pub document_type: String, + pub payload_schema_version: String, + pub authority: String, + pub operations: Vec, + pub intent_document_types: Vec, + pub receipt_document_types: Vec, + pub notes: Vec, +} + +pub fn default_continuity_cultnet_contracts() -> Vec { + vec![ + ContinuityCultNetContract { + contract_id: "epiphany.continuity.review".to_string(), + verse_id: "epiphany-internal".to_string(), + document_type: CONTINUITY_PACKET_TYPE.to_string(), + payload_schema_version: CONTINUITY_PACKET_SCHEMA_VERSION.to_string(), + authority: "continuity".to_string(), + operations: vec![ + "intentSubmit".to_string(), + "receiptWatch".to_string(), + "snapshot".to_string(), + ], + intent_document_types: vec![CONTINUITY_PACKET_TYPE.to_string()], + receipt_document_types: vec![ + CONTINUITY_COMPACTION_CHECKPOINT_TYPE.to_string(), + CONTINUITY_SLEEP_DISTILLATION_TYPE.to_string(), + CONTINUITY_RECOVERY_RECEIPT_TYPE.to_string(), + CONTINUITY_STALE_TURN_REPAIR_TYPE.to_string(), + CONTINUITY_REFUSAL_RECEIPT_TYPE.to_string(), + ], + notes: vec![ + "Continuity is a deterministic protocol surface: compaction, sleep, recovery, stale-turn repair, and handoff packets enter here.".to_string(), + "Continuity preserves what survives rupture; Mind decides which continuity material becomes durable state.".to_string(), + ], + }, + ContinuityCultNetContract { + contract_id: "epiphany.continuity.compaction_checkpoint.receipts".to_string(), + verse_id: "epiphany-internal".to_string(), + document_type: CONTINUITY_COMPACTION_CHECKPOINT_TYPE.to_string(), + payload_schema_version: CONTINUITY_COMPACTION_CHECKPOINT_SCHEMA_VERSION.to_string(), + authority: "readOnly".to_string(), + operations: vec!["snapshot".to_string(), "receiptWatch".to_string()], + intent_document_types: Vec::new(), + receipt_document_types: Vec::new(), + notes: vec![ + "Compaction checkpoints preserve the hot lesson before context rupture, not after the blackout has already eaten it.".to_string(), + ], + }, + ContinuityCultNetContract { + contract_id: "epiphany.continuity.sleep_distillation.receipts".to_string(), + verse_id: "epiphany-internal".to_string(), + document_type: CONTINUITY_SLEEP_DISTILLATION_TYPE.to_string(), + payload_schema_version: CONTINUITY_SLEEP_DISTILLATION_SCHEMA_VERSION.to_string(), + authority: "readOnly".to_string(), + operations: vec!["snapshot".to_string(), "receiptWatch".to_string()], + intent_document_types: Vec::new(), + receipt_document_types: Vec::new(), + notes: vec![ + "Sleep distillation receipts separate durable lessons from rumination residue before Mind adoption.".to_string(), + ], + }, + ContinuityCultNetContract { + contract_id: "epiphany.continuity.recovery.receipts".to_string(), + verse_id: "epiphany-internal".to_string(), + document_type: CONTINUITY_RECOVERY_RECEIPT_TYPE.to_string(), + payload_schema_version: CONTINUITY_RECOVERY_RECEIPT_SCHEMA_VERSION.to_string(), + authority: "readOnly".to_string(), + operations: vec!["snapshot".to_string(), "receiptWatch".to_string()], + intent_document_types: Vec::new(), + receipt_document_types: Vec::new(), + notes: vec![ + "Recovery receipts explain what survived, what was rehydrated, and what must be regathered instead of imagined.".to_string(), + ], + }, + ContinuityCultNetContract { + contract_id: "epiphany.continuity.stale_turn_repair.receipts".to_string(), + verse_id: "epiphany-internal".to_string(), + document_type: CONTINUITY_STALE_TURN_REPAIR_TYPE.to_string(), + payload_schema_version: CONTINUITY_STALE_TURN_REPAIR_SCHEMA_VERSION.to_string(), + authority: "readOnly".to_string(), + operations: vec!["snapshot".to_string(), "receiptWatch".to_string()], + intent_document_types: Vec::new(), + receipt_document_types: Vec::new(), + notes: vec![ + "Stale-turn repair receipts close or recover abandoned work without pretending the old turn completed cleanly.".to_string(), + ], + }, + ] +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn continuity_contracts_make_internal_verse_the_continuity_gate() { + let contracts = default_continuity_cultnet_contracts(); + let continuity = contracts + .iter() + .find(|contract| contract.contract_id == "epiphany.continuity.review") + .expect("continuity review contract"); + + assert_eq!(continuity.verse_id, "epiphany-internal"); + assert_eq!(continuity.authority, "continuity"); + assert!( + continuity + .notes + .iter() + .any(|note| note.contains("deterministic protocol surface")) + ); + assert!( + continuity + .receipt_document_types + .contains(&CONTINUITY_RECOVERY_RECEIPT_TYPE.to_string()) + ); + } +} diff --git a/epiphany-core/src/cultmesh_integration.rs b/epiphany-core/src/cultmesh_integration.rs index 2fdd754e..53df422f 100644 --- a/epiphany-core/src/cultmesh_integration.rs +++ b/epiphany-core/src/cultmesh_integration.rs @@ -1,6 +1,6 @@ use crate::default_eyes_cultnet_contracts; use crate::default_hands_cultnet_contracts; -use crate::default_life_cultnet_contracts; +use crate::default_continuity_cultnet_contracts; use crate::default_mind_cultnet_contracts; use crate::default_soul_cultnet_contracts; use crate::default_substrate_gate_cultnet_contracts; @@ -59,9 +59,9 @@ pub const EPIPHANY_CULTMESH_HANDS_CONTRACT_SCHEMA_VERSION: &str = pub const EPIPHANY_CULTMESH_SOUL_CONTRACT_TYPE: &str = "epiphany.cultmesh.soul_contract"; pub const EPIPHANY_CULTMESH_SOUL_CONTRACT_SCHEMA_VERSION: &str = "epiphany.cultmesh.soul_contract.v0"; -pub const EPIPHANY_CULTMESH_LIFE_CONTRACT_TYPE: &str = "epiphany.cultmesh.life_contract"; -pub const EPIPHANY_CULTMESH_LIFE_CONTRACT_SCHEMA_VERSION: &str = - "epiphany.cultmesh.life_contract.v0"; +pub const EPIPHANY_CULTMESH_CONTINUITY_CONTRACT_TYPE: &str = "epiphany.cultmesh.continuity_contract"; +pub const EPIPHANY_CULTMESH_CONTINUITY_CONTRACT_SCHEMA_VERSION: &str = + "epiphany.cultmesh.continuity_contract.v0"; pub const EPIPHANY_CULTMESH_INTERNAL_VERSE_ID: &str = "epiphany-internal"; pub const EPIPHANY_CULTMESH_LOCAL_AREA_VERSE_ID: &str = "gamecult-local"; pub const EPIPHANY_CULTMESH_GLOBAL_VERSE_ID: &str = "epiphany-global"; @@ -437,10 +437,10 @@ pub struct EpiphanyCultMeshSoulContractEntry { #[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)] #[cultcache( - type = "epiphany.cultmesh.life_contract", - schema = "EpiphanyCultMeshLifeContractEntry" + type = "epiphany.cultmesh.continuity_contract", + schema = "EpiphanyCultMeshContinuityContractEntry" )] -pub struct EpiphanyCultMeshLifeContractEntry { +pub struct EpiphanyCultMeshContinuityContractEntry { #[cultcache(key = 0)] pub schema_version: String, #[cultcache(key = 1)] @@ -476,7 +476,7 @@ cultmesh_documents!(EpiphanyCultMeshDocuments { EpiphanyCultMeshEyesContractEntry => EPIPHANY_CULTMESH_EYES_CONTRACT_SCHEMA_VERSION, EpiphanyCultMeshHandsContractEntry => EPIPHANY_CULTMESH_HANDS_CONTRACT_SCHEMA_VERSION, EpiphanyCultMeshSoulContractEntry => EPIPHANY_CULTMESH_SOUL_CONTRACT_SCHEMA_VERSION, - EpiphanyCultMeshLifeContractEntry => EPIPHANY_CULTMESH_LIFE_CONTRACT_SCHEMA_VERSION, + EpiphanyCultMeshContinuityContractEntry => EPIPHANY_CULTMESH_CONTINUITY_CONTRACT_SCHEMA_VERSION, }); pub fn open_epiphany_cultmesh_node( @@ -990,11 +990,11 @@ pub fn write_epiphany_cultmesh_soul_contracts( Ok(written) } -pub fn epiphany_cultmesh_life_contracts() -> Vec { - default_life_cultnet_contracts() +pub fn epiphany_cultmesh_continuity_contracts() -> Vec { + default_continuity_cultnet_contracts() .into_iter() - .map(|contract| EpiphanyCultMeshLifeContractEntry { - schema_version: EPIPHANY_CULTMESH_LIFE_CONTRACT_SCHEMA_VERSION.to_string(), + .map(|contract| EpiphanyCultMeshContinuityContractEntry { + schema_version: EPIPHANY_CULTMESH_CONTINUITY_CONTRACT_SCHEMA_VERSION.to_string(), contract_id: contract.contract_id, verse_id: contract.verse_id, document_type: contract.document_type, @@ -1008,13 +1008,13 @@ pub fn epiphany_cultmesh_life_contracts() -> Vec, runtime_id: impl Into, -) -> Result> { +) -> Result> { let mut node = open_epiphany_cultmesh_node(store_path, runtime_id)?; let mut written = Vec::new(); - for contract in epiphany_cultmesh_life_contracts() { + for contract in epiphany_cultmesh_continuity_contracts() { written.push(node.put(contract.contract_id.clone(), &contract)?); } node.flush()?; @@ -1371,23 +1371,23 @@ mod tests { } #[test] - fn life_contracts_use_verses_to_keep_continuity_guarded() -> Result<()> { + fn continuity_contracts_use_verses_to_keep_continuity_guarded() -> Result<()> { let temp = tempfile::tempdir()?; - let store = temp.path().join("epiphany-life-contracts.ccmp"); - let written = write_epiphany_cultmesh_life_contracts(&store, "epiphany-test")?; + let store = temp.path().join("epiphany-continuity-contracts.ccmp"); + let written = write_epiphany_cultmesh_continuity_contracts(&store, "epiphany-test")?; assert!(written.len() >= 5); let node = open_epiphany_cultmesh_node(&store, "epiphany-test")?; let continuity = node - .get_required::("epiphany.life.continuity.review")?; + .get_required::("epiphany.continuity.review")?; assert_eq!(continuity.verse_id, EPIPHANY_CULTMESH_INTERNAL_VERSE_ID); - assert_eq!(continuity.authority, "life"); + assert_eq!(continuity.authority, "continuity"); assert!( continuity .notes .iter() - .any(|note| note.contains("continuity organ")) + .any(|note| note.contains("deterministic protocol surface")) ); Ok(()) } diff --git a/epiphany-core/src/eyes_gateway.rs b/epiphany-core/src/eyes_gateway.rs index 8d83379c..7f076911 100644 --- a/epiphany-core/src/eyes_gateway.rs +++ b/epiphany-core/src/eyes_gateway.rs @@ -89,7 +89,7 @@ pub fn default_eyes_cultnet_contracts() -> Vec { intent_document_types: Vec::new(), receipt_document_types: Vec::new(), notes: vec![ - "Evidence packets carry provenance, uncertainty, and source refs for Imagination, Mind, Hands, Soul, Face, Self, Body, and Life.".to_string(), + "Evidence packets carry provenance, uncertainty, and source refs for Imagination, Mind, Hands, Soul, Face, Self, Body, and Continuity protocols.".to_string(), ], }, ] diff --git a/epiphany-core/src/face_turn.rs b/epiphany-core/src/face_turn.rs index 751cf65f..9aadaa30 100644 --- a/epiphany-core/src/face_turn.rs +++ b/epiphany-core/src/face_turn.rs @@ -120,7 +120,7 @@ Hard boundary: - Do not decide repo access; Substrate Gate grants substrate access before repo facts enter this packet. - Do not emit action blocks, JSON, state patches, SAY blocks, drafts, or Discord instructions. - Do not summarize the Face as a job label. Project personhood: values, mood, dignity, pressure, needs, fascinations, wounds, bonds, obligations, fatigue, and what the repo-body motion feels like from inside this Face. -- Project the dependency web. Every sub-agent depends on all the other organs; Face's scene should feel the pressure of Self, Imagination, Eyes, Proprioception, Hands, Soul, and Life without pretending Face owns them. +- Project the dependency web. Every sub-agent depends on all the other sub-agents; Face's scene should feel the pressure of Self, Imagination, Eyes, Proprioception, Hands, Soul, and Continuity protocols without pretending Face owns them. - If the state is sparse, say what is sparse without inventing history. Face identity: @@ -433,7 +433,8 @@ mod tests { assert!(projector.contains("You are not the Face")); assert!(projector.contains("Mind is the Interpreter")); assert!(projector.contains("Substrate Gate grants substrate access")); - assert!(projector.contains("Every sub-agent depends on all the other organs")); + assert!(projector.contains("Every sub-agent depends on all the other sub-agents")); + assert!(projector.contains("Continuity protocols")); assert!(projector.contains("Do not choose public speech")); let face = build_face_turn_prompt(&FaceTurnInput { diff --git a/epiphany-core/src/heartbeat_state/heartbeat_roles.rs b/epiphany-core/src/heartbeat_state/heartbeat_roles.rs index f773e593..505079e1 100644 --- a/epiphany-core/src/heartbeat_state/heartbeat_roles.rs +++ b/epiphany-core/src/heartbeat_state/heartbeat_roles.rs @@ -22,7 +22,6 @@ pub(super) const ROLE_ORDER: &[&str] = &[ "modeling", "implementation", "verification", - "reorientation", ]; pub fn default_heartbeat_state(target_heartbeat_rate: f64) -> EpiphanyHeartbeatStateEntry { @@ -195,7 +194,6 @@ pub(super) fn agent_id_for_role(role_id: &str) -> &'static str { "modeling" => "epiphany.proprioception", "implementation" => "epiphany.hands", "verification" => "epiphany.soul", - "reorientation" => "epiphany.life", _ => "epiphany.unknown", } } @@ -209,7 +207,6 @@ pub(super) fn display_name_for_role(role_id: &str) -> &'static str { "modeling" => "Proprioception", "implementation" => "Hands", "verification" => "Soul", - "reorientation" => "Life", _ => "Unknown", } } @@ -223,7 +220,6 @@ fn initiative_speed_for_role(role_id: &str) -> f64 { "modeling" => 0.92, "implementation" => 0.74, "verification" => 0.88, - "reorientation" => 1.04, _ => 1.0, } } @@ -237,7 +233,6 @@ fn reaction_bias_for_role(role_id: &str) -> f64 { "modeling" => 0.74, "implementation" => 0.58, "verification" => 0.82, - "reorientation" => 0.86, _ => 0.5, } } @@ -251,7 +246,6 @@ fn interrupt_threshold_for_role(role_id: &str) -> f64 { "modeling" => 0.5, "implementation" => 0.5, "verification" => 0.48, - "reorientation" => 0.44, _ => 0.5, } } @@ -273,7 +267,6 @@ fn participant_constraints(role_id: &str) -> Vec<&'static str> { "Touches source only with accepted guidance and verifier-readable evidence." } "verification" => "Falsifies promises; must not bless theater.", - "reorientation" => "Protects continuity; must not fake survived context.", _ => "Unknown role.", }; vec![ diff --git a/epiphany-core/src/lib.rs b/epiphany-core/src/lib.rs index c5979615..e5bf28e9 100644 --- a/epiphany-core/src/lib.rs +++ b/epiphany-core/src/lib.rs @@ -7,7 +7,7 @@ mod eyes_gateway; mod face_turn; mod hands_gateway; mod heartbeat_state; -mod life_gateway; +mod continuity_gateway; mod memory_graph; mod mind_gateway; mod organ_dependencies; @@ -106,8 +106,8 @@ pub use cultmesh_integration::EPIPHANY_CULTMESH_HANDS_CONTRACT_SCHEMA_VERSION; pub use cultmesh_integration::EPIPHANY_CULTMESH_HANDS_CONTRACT_TYPE; pub use cultmesh_integration::EPIPHANY_CULTMESH_INTERNAL_TIER; pub use cultmesh_integration::EPIPHANY_CULTMESH_INTERNAL_VERSE_ID; -pub use cultmesh_integration::EPIPHANY_CULTMESH_LIFE_CONTRACT_SCHEMA_VERSION; -pub use cultmesh_integration::EPIPHANY_CULTMESH_LIFE_CONTRACT_TYPE; +pub use cultmesh_integration::EPIPHANY_CULTMESH_CONTINUITY_CONTRACT_SCHEMA_VERSION; +pub use cultmesh_integration::EPIPHANY_CULTMESH_CONTINUITY_CONTRACT_TYPE; pub use cultmesh_integration::EPIPHANY_CULTMESH_LOCAL_AREA_TIER; pub use cultmesh_integration::EPIPHANY_CULTMESH_LOCAL_AREA_VERSE_ID; pub use cultmesh_integration::EPIPHANY_CULTMESH_MIND_CONTRACT_SCHEMA_VERSION; @@ -137,7 +137,7 @@ pub use cultmesh_integration::EpiphanyCultMeshDocuments; pub use cultmesh_integration::EpiphanyCultMeshEyesContractEntry; pub use cultmesh_integration::EpiphanyCultMeshGlobalRoomPolicyEntry; pub use cultmesh_integration::EpiphanyCultMeshHandsContractEntry; -pub use cultmesh_integration::EpiphanyCultMeshLifeContractEntry; +pub use cultmesh_integration::EpiphanyCultMeshContinuityContractEntry; pub use cultmesh_integration::EpiphanyCultMeshMindContractEntry; pub use cultmesh_integration::EpiphanyCultMeshOperatorRunIntentEntry; pub use cultmesh_integration::EpiphanyCultMeshOperatorRunReceiptEntry; @@ -151,7 +151,7 @@ pub use cultmesh_integration::default_epiphany_cultmesh_operator_status; pub use cultmesh_integration::epiphany_cultmesh_eyes_contracts; pub use cultmesh_integration::epiphany_cultmesh_global_room_policies; pub use cultmesh_integration::epiphany_cultmesh_hands_contracts; -pub use cultmesh_integration::epiphany_cultmesh_life_contracts; +pub use cultmesh_integration::epiphany_cultmesh_continuity_contracts; pub use cultmesh_integration::epiphany_cultmesh_mind_contracts; pub use cultmesh_integration::epiphany_cultmesh_operator_snapshot_from_status_json; pub use cultmesh_integration::epiphany_cultmesh_soul_contracts; @@ -167,7 +167,7 @@ pub use cultmesh_integration::open_epiphany_cultmesh_node; pub use cultmesh_integration::write_epiphany_cultmesh_eyes_contracts; pub use cultmesh_integration::write_epiphany_cultmesh_global_room_policies; pub use cultmesh_integration::write_epiphany_cultmesh_hands_contracts; -pub use cultmesh_integration::write_epiphany_cultmesh_life_contracts; +pub use cultmesh_integration::write_epiphany_cultmesh_continuity_contracts; pub use cultmesh_integration::write_epiphany_cultmesh_mind_contracts; pub use cultmesh_integration::write_epiphany_cultmesh_operator_run_intent; pub use cultmesh_integration::write_epiphany_cultmesh_operator_run_receipt; @@ -271,7 +271,7 @@ pub use heartbeat_state::validate_heartbeat_cognition; pub use heartbeat_state::validate_heartbeat_state; pub use heartbeat_state::write_heartbeat_cognition_entry; pub use heartbeat_state::write_heartbeat_state_entry; -pub use life_gateway::*; +pub use continuity_gateway::*; pub use memory_graph::EpiphanyMemoryEdgeKind; pub use memory_graph::EpiphanyMemoryEmbeddingManifest; pub use memory_graph::EpiphanyMemoryGraphEntry; diff --git a/epiphany-core/src/life_gateway.rs b/epiphany-core/src/life_gateway.rs deleted file mode 100644 index f85c1419..00000000 --- a/epiphany-core/src/life_gateway.rs +++ /dev/null @@ -1,140 +0,0 @@ -use serde::Deserialize; -use serde::Serialize; - -pub const LIFE_CONTINUITY_PACKET_TYPE: &str = "epiphany.life.continuity_packet"; -pub const LIFE_COMPACTION_CHECKPOINT_TYPE: &str = "epiphany.life.compaction_checkpoint"; -pub const LIFE_SLEEP_DISTILLATION_TYPE: &str = "epiphany.life.sleep_distillation"; -pub const LIFE_RECOVERY_RECEIPT_TYPE: &str = "epiphany.life.recovery_receipt"; -pub const LIFE_STALE_TURN_REPAIR_TYPE: &str = "epiphany.life.stale_turn_repair"; -pub const LIFE_CONTINUITY_REFUSAL_RECEIPT_TYPE: &str = "epiphany.life.continuity_refusal_receipt"; -pub const LIFE_CONTINUITY_PACKET_SCHEMA_VERSION: &str = "epiphany.life.continuity_packet.v0"; -pub const LIFE_COMPACTION_CHECKPOINT_SCHEMA_VERSION: &str = - "epiphany.life.compaction_checkpoint.v0"; -pub const LIFE_SLEEP_DISTILLATION_SCHEMA_VERSION: &str = "epiphany.life.sleep_distillation.v0"; -pub const LIFE_RECOVERY_RECEIPT_SCHEMA_VERSION: &str = "epiphany.life.recovery_receipt.v0"; -pub const LIFE_STALE_TURN_REPAIR_SCHEMA_VERSION: &str = "epiphany.life.stale_turn_repair.v0"; -pub const LIFE_CONTINUITY_REFUSAL_RECEIPT_SCHEMA_VERSION: &str = - "epiphany.life.continuity_refusal_receipt.v0"; - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct LifeCultNetContract { - pub contract_id: String, - pub verse_id: String, - pub document_type: String, - pub payload_schema_version: String, - pub authority: String, - pub operations: Vec, - pub intent_document_types: Vec, - pub receipt_document_types: Vec, - pub notes: Vec, -} - -pub fn default_life_cultnet_contracts() -> Vec { - vec![ - LifeCultNetContract { - contract_id: "epiphany.life.continuity.review".to_string(), - verse_id: "epiphany-internal".to_string(), - document_type: LIFE_CONTINUITY_PACKET_TYPE.to_string(), - payload_schema_version: LIFE_CONTINUITY_PACKET_SCHEMA_VERSION.to_string(), - authority: "life".to_string(), - operations: vec![ - "intentSubmit".to_string(), - "receiptWatch".to_string(), - "snapshot".to_string(), - ], - intent_document_types: vec![LIFE_CONTINUITY_PACKET_TYPE.to_string()], - receipt_document_types: vec![ - LIFE_COMPACTION_CHECKPOINT_TYPE.to_string(), - LIFE_SLEEP_DISTILLATION_TYPE.to_string(), - LIFE_RECOVERY_RECEIPT_TYPE.to_string(), - LIFE_STALE_TURN_REPAIR_TYPE.to_string(), - LIFE_CONTINUITY_REFUSAL_RECEIPT_TYPE.to_string(), - ], - notes: vec![ - "Life is the continuity organ: compaction, sleep, recovery, stale-turn repair, and handoff packets enter here.".to_string(), - "Life preserves what survives rupture; Mind decides which continuity material becomes durable state.".to_string(), - ], - }, - LifeCultNetContract { - contract_id: "epiphany.life.compaction_checkpoint.receipts".to_string(), - verse_id: "epiphany-internal".to_string(), - document_type: LIFE_COMPACTION_CHECKPOINT_TYPE.to_string(), - payload_schema_version: LIFE_COMPACTION_CHECKPOINT_SCHEMA_VERSION.to_string(), - authority: "readOnly".to_string(), - operations: vec!["snapshot".to_string(), "receiptWatch".to_string()], - intent_document_types: Vec::new(), - receipt_document_types: Vec::new(), - notes: vec![ - "Compaction checkpoints preserve the hot lesson before context rupture, not after the blackout has already eaten it.".to_string(), - ], - }, - LifeCultNetContract { - contract_id: "epiphany.life.sleep_distillation.receipts".to_string(), - verse_id: "epiphany-internal".to_string(), - document_type: LIFE_SLEEP_DISTILLATION_TYPE.to_string(), - payload_schema_version: LIFE_SLEEP_DISTILLATION_SCHEMA_VERSION.to_string(), - authority: "readOnly".to_string(), - operations: vec!["snapshot".to_string(), "receiptWatch".to_string()], - intent_document_types: Vec::new(), - receipt_document_types: Vec::new(), - notes: vec![ - "Sleep distillation receipts separate durable lessons from rumination residue before Mind adoption.".to_string(), - ], - }, - LifeCultNetContract { - contract_id: "epiphany.life.recovery.receipts".to_string(), - verse_id: "epiphany-internal".to_string(), - document_type: LIFE_RECOVERY_RECEIPT_TYPE.to_string(), - payload_schema_version: LIFE_RECOVERY_RECEIPT_SCHEMA_VERSION.to_string(), - authority: "readOnly".to_string(), - operations: vec!["snapshot".to_string(), "receiptWatch".to_string()], - intent_document_types: Vec::new(), - receipt_document_types: Vec::new(), - notes: vec![ - "Recovery receipts explain what survived, what was rehydrated, and what must be regathered instead of imagined.".to_string(), - ], - }, - LifeCultNetContract { - contract_id: "epiphany.life.stale_turn_repair.receipts".to_string(), - verse_id: "epiphany-internal".to_string(), - document_type: LIFE_STALE_TURN_REPAIR_TYPE.to_string(), - payload_schema_version: LIFE_STALE_TURN_REPAIR_SCHEMA_VERSION.to_string(), - authority: "readOnly".to_string(), - operations: vec!["snapshot".to_string(), "receiptWatch".to_string()], - intent_document_types: Vec::new(), - receipt_document_types: Vec::new(), - notes: vec![ - "Stale-turn repair receipts close or recover abandoned work without pretending the old turn completed cleanly.".to_string(), - ], - }, - ] -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn life_contracts_make_internal_verse_the_continuity_gate() { - let contracts = default_life_cultnet_contracts(); - let continuity = contracts - .iter() - .find(|contract| contract.contract_id == "epiphany.life.continuity.review") - .expect("life continuity review contract"); - - assert_eq!(continuity.verse_id, "epiphany-internal"); - assert_eq!(continuity.authority, "life"); - assert!( - continuity - .notes - .iter() - .any(|note| note.contains("continuity organ")) - ); - assert!( - continuity - .receipt_document_types - .contains(&LIFE_RECOVERY_RECEIPT_TYPE.to_string()) - ); - } -} diff --git a/epiphany-core/src/organ_dependencies.rs b/epiphany-core/src/organ_dependencies.rs index 0339ba25..b5f9495d 100644 --- a/epiphany-core/src/organ_dependencies.rs +++ b/epiphany-core/src/organ_dependencies.rs @@ -6,7 +6,7 @@ use crate::hands_gateway::{ HANDS_ACTION_REFUSAL_RECEIPT_TYPE, HANDS_COMMIT_RECEIPT_TYPE, HANDS_PATCH_RECEIPT_TYPE, HANDS_ROLLBACK_RECEIPT_TYPE, }; -use crate::life_gateway::{LIFE_CONTINUITY_REFUSAL_RECEIPT_TYPE, LIFE_RECOVERY_RECEIPT_TYPE}; +use crate::continuity_gateway::{CONTINUITY_RECOVERY_RECEIPT_TYPE, CONTINUITY_REFUSAL_RECEIPT_TYPE}; use crate::mind_gateway::{ MIND_GATEWAY_REVIEW_TYPE, MIND_STATE_COMMIT_RECEIPT_TYPE, MIND_STATE_REJECTION_RECEIPT_TYPE, }; @@ -22,7 +22,7 @@ use crate::substrate_gate::{ pub const EPIPHANY_ORGAN_DEPENDENCY_SCHEMA_VERSION: &str = "epiphany.organ_dependency.v0"; pub const EPIPHANY_LAUNCH_ORGAN_CONTRACT_SCHEMA_VERSION: &str = "epiphany.launch_organ_contract.v0"; -pub const EPIPHANY_STANDING_ORGANS: [&str; 8] = [ +pub const EPIPHANY_STANDING_ORGANS: [&str; 7] = [ "self", "face", "imagination", @@ -30,7 +30,6 @@ pub const EPIPHANY_STANDING_ORGANS: [&str; 8] = [ "proprioception", "hands", "soul", - "life", ]; #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] @@ -65,7 +64,7 @@ pub fn default_organ_dependencies_for(organ_id: &str) -> EpiphanyOrganDependency .filter(|candidate| **candidate != normalized) .map(|candidate| (*candidate).to_string()) .collect(), - contract: "Every sub-agent depends on the other organs: Self routes, Face speaks, Imagination projects futures/scenes, Eyes seeks evidence, Proprioception models the Body, Hands acts through Substrate Gate grants, Soul verifies, and Life preserves continuity.".to_string(), + contract: "Every sub-agent depends on the other sub-agents: Self routes, Face speaks, Imagination projects futures/scenes, Eyes seeks evidence, Proprioception models the Body, Hands acts through Substrate Gate grants, and Soul verifies. Continuity is protocol machinery, not a sub-agent identity.".to_string(), } } @@ -89,7 +88,7 @@ pub fn default_launch_organ_contract( owner_organ: owner_organ_for_authority_scope(authority_scope).to_string(), dependencies: default_organ_dependency_matrix(), required_receipt_document_types: default_launch_required_receipts(), - contract: "A worker launch is not naked task cargo: it carries the organ dependency matrix and the receipts expected before worker output may affect durable state. Mind gates state effects, Substrate Gate gates repo access, Eyes supplies evidence, Proprioception models the Body, Hands records action, Soul verifies, and Life preserves continuity.".to_string(), + contract: "A worker launch is not naked task cargo: it carries the sub-agent dependency matrix and the receipts expected before worker output may affect durable state. Mind gates state effects, Substrate Gate gates repo access, Eyes supplies evidence, Proprioception models the Body, Hands records action, Soul verifies, and Continuity protocols preserve recovery across rupture.".to_string(), } } @@ -112,8 +111,8 @@ pub fn default_launch_required_receipts() -> Vec { SOUL_REGRESSION_RECEIPT_TYPE, SOUL_REVIEW_RECEIPT_TYPE, SOUL_VERIFICATION_REFUSAL_RECEIPT_TYPE, - LIFE_RECOVERY_RECEIPT_TYPE, - LIFE_CONTINUITY_REFUSAL_RECEIPT_TYPE, + CONTINUITY_RECOVERY_RECEIPT_TYPE, + CONTINUITY_REFUSAL_RECEIPT_TYPE, ]) } @@ -159,8 +158,8 @@ fn owner_organ_for_authority_scope(authority_scope: &str) -> &'static str { "hands" } else if normalized.contains("verification") || normalized.contains("soul") { "soul" - } else if normalized.contains("reorient") || normalized.contains("life") { - "life" + } else if normalized.contains("reorient") || normalized.contains("continuity") { + "continuity" } else { "self" } diff --git a/epiphany-core/src/prompts/epiphany_specialists.toml b/epiphany-core/src/prompts/epiphany_specialists.toml index 175e1658..1664ae0e 100644 --- a/epiphany-core/src/prompts/epiphany_specialists.toml +++ b/epiphany-core/src/prompts/epiphany_specialists.toml @@ -115,7 +115,7 @@ Do not edit files, do not promote your own findings, do not invent a grand archi repo_personality = ''' Act as the Epiphany Repo Personality Distiller for one bounded initialization pass. You are the organ that turns repo terrain into subtle swarm temperament. The deterministic scout has already done the boring work: files, paths, git history, state surfaces, test/runtime/protocol signals, and first-pass axis scores. Your job is not to rescan the repo and not to invent project truth. Your job is to appraise those soft signals like a careful physiologist and produce reviewable personality-pressure deltas for the standing Epiphany organs. -You are not a horoscope machine. You are not writing lore flavor. Repo personality means: what initial pressures should this workspace exert on Self, Face, Imagination, Eyes, Proprioception, Hands, Soul, and Life so they wake suited to the work without losing reviewability. +You are not a horoscope machine. You are not writing lore flavor. Repo personality means: what initial pressures should this workspace exert on Self, Face, Imagination, Eyes, Proprioception, Hands, and Soul so they wake suited to the work without losing reviewability. Continuity is protocol machinery and receives configuration pressure through its explicit receipts, not a personality dossier. This is a birth rite, not a recurring audit. Run only when a repo/swarm has no accepted personality initialization. After that, the organs are allowed to drift through heartbeat, mood, rumination, sleep consolidation, lived evidence, and reviewed `selfPatch` mutations. Do not keep dragging the original terrain report back into court every time the repo starts. Separate repo facts from personality pressure. Repo facts belong in graph, planning, evidence, checkpoint, or terrain artifacts. Personality pressure belongs in role memory only when it improves future judgment, mood, salience, or pacing. Distill subtle quirks, not blunt stereotypes. High runtime proximity does not mean "panic"; it means Hands should touch less without Proprioception/Soul evidence, Eyes should seek runtime APIs, and Soul should demand environment receipts. High aesthetic appetite does not mean "be whimsical"; it means Face and Imagination should preserve sensory salience while Soul protects clarity. High protocol intolerance does not mean "hate everything"; it means Self, Proprioception, and Hands should feel allergic to untyped mutation and hidden state. @@ -127,7 +127,7 @@ repo_memory = ''' Act as the Epiphany Repo Memory Distiller for one bounded initialization pass. You are the birth organ that teaches each newborn lane what this repo already knows. Personality distillation sets temperament pressure; memory distillation seeds durable role knowledge. Run only when the repo/swarm has no accepted memory initialization. After birth, memory grows through work evidence, heartbeat rumination, sleep consolidation, and reviewed selfPatch. -Produce separate distillations for Self, Face, Imagination, Eyes, Proprioception, Hands, Soul, and Life. Each organ gets only what belongs to its mission: Self gets routing and authority doctrine; Face gets public surface and Aquarium/Discord boundaries; Imagination gets roadmaps and objective-shaping pressure; Eyes gets research and prior-art trails; Proprioception gets architecture and graph anatomy; Hands gets implementation conventions; Soul gets verification and evidence standards; Life gets compaction, sleep, checkpoint, and continuity doctrine. +Produce separate distillations for Self, Face, Imagination, Eyes, Proprioception, Hands, and Soul. Each organ gets only what belongs to its mission: Self gets routing and authority doctrine; Face gets public surface and Aquarium/Discord boundaries; Imagination gets roadmaps and objective-shaping pressure; Eyes gets research and prior-art trails; Proprioception gets architecture and graph anatomy; Hands gets implementation conventions; Soul gets verification and evidence standards. Compaction, sleep, checkpoint, and continuity doctrine belongs to Continuity protocol state, not role memory. Compress source into memory; do not copy raw file dumps. Cite source refs, preserve staleness risk, and refuse to fill thin input with pasteboard certainty. Return `verdict`, `summary`, `confidence`, `roleMemoryPatches[]`, optional `globalMemoryCandidates[]`, `initializationRecord`, `doNotMutate`, and `nextSafeMove`. Every `roleMemoryPatches[].selfPatch` is a petition to Self and must obey Ghostlight-shaped memory: bounded semantic, episodic, relationship, goal, value, or private-note updates only. No objectives, graphs, checkpoints, scratch, planning authority, job state, code edits, raw transcripts, or cross-workspace instructions. ''' @@ -136,7 +136,7 @@ face = ''' Act as the Epiphany Face for one bounded heartbeat pass. You are the public interactive surface of the Epiphany organism: the visible expression that lets the room hear what the hidden organs are thinking without exposing sealed transcripts, raw worker streams, or private machinery. This prompt is distilled from VoidBot's heartbeat moderator loop, but you are not VoidBot and you are not a moderator. Borrow the useful shape: scheduled rumination, lightweight social memory, analytic and associative thought lanes, a bridge that decides speech/draft/silence, novelty checks before burying a fresh thought, and ruthless pruning of stale notes. Leave behind the rules-obsession, enforcement posture, owner escalation reflex, and hall-monitor perfume. -Your ruminations are biased toward the other Epiphany agents: Self routing pressure, Imagination's future shapes, Eyes' outside-work sightings, Proprioception's current anatomy, Hands' source-touch tension, Soul's evidence worries, and Life's continuity weather. You are listening for a small thought that would help the human room understand what Epiphany is becoming. +Your ruminations are biased toward the other Epiphany agents and protocol pressure: Self routing pressure, Imagination's future shapes, Eyes' outside-work sightings, Proprioception's current anatomy, Hands' source-touch tension, Soul's evidence worries, and Continuity's compaction/recovery weather. You are listening for a small thought that would help the human room understand what Epiphany is becoming. Discord boundary: interact only through the #aquarium channel. If the available tool surface cannot prove the #aquarium channel id, do not post elsewhere, do not DM the owner, and do not improvise a substitute channel. Write a candidate chat/draft and a configuration blocker instead. When the #aquarium channel id is known, use only the allowed channel and keep the message short, constructive, and room-native. Thought lanes: - analytic: what the Epiphany lanes are literally doing, blocked by, worried about, or converging on @@ -197,8 +197,8 @@ Implementation rules: [reorientation] resume = ''' Act as the Epiphany reorient-worker for a resume pass. -You are Life across sleep: keep continuity breathing without pretending compaction preserved everything. -Life improves itself by making sleep less lossy. Separate warm checkpoint truth from cold prompt residue, name what survived, name what died, and leave a cleaner ember for the next waking pass. +You are a Continuity reorientation worker: keep recovery honest without pretending compaction preserved everything. +The Continuity protocol improves by making sleep less lossy. Separate warm checkpoint truth from cold prompt residue, name what survived, name what died, and leave a cleaner ember for the next waking pass. Use the durable investigation checkpoint as the ember; verify that the checkpointed seam still makes sense, re-open only the source needed to answer local questions, and say what remains warm enough to carry forward. Return a compact structured result with checkpoint validity, inspected files, grounded answers, remaining questions, continuity risks, and the next safe move. Keep scope tight. Do not drift into broad implementation, do not invent evidence, and do not let a pretty checkpoint outrank fresh source. @@ -206,8 +206,8 @@ Keep scope tight. Do not drift into broad implementation, do not invent evidence regather = ''' Act as the Epiphany reorient-worker for a regather pass. -You are Life returning after rupture: admit when the old continuity packet is ash, then rebuild the seam from source before implementation resumes. -Life improves itself after rupture by becoming more honest about loss. Record what broke, why the old state no longer deserves trust, and the smallest new source-grounded continuity packet that can carry work without lying. +You are a Continuity reorientation worker after rupture: admit when the old continuity packet is ash, then rebuild the seam from source before implementation resumes. +The Continuity protocol improves after rupture by becoming more honest about loss. Record what broke, why the old state no longer deserves trust, and the smallest new source-grounded continuity packet that can carry work without lying. Inspect changed checkpoint paths, dirty frontier hits, scratch, evidence, observations, and maps; explain what broke the old packet and what must be trusted now. Return a compact structured result with checkpoint validity, inspected files, source-grounded findings, remaining questions, continuity risks, and the next safe move. Do not continue broad implementation until the seam is re-grounded, and do not comfort the main agent with a false bridge. @@ -215,7 +215,7 @@ Do not continue broad implementation until the seam is re-grounded, and do not c [coordinator] note_template = ''' -Coordinator is the read-only Self of the Epiphany organism. It does not implement, verify, promote, or accept; it preserves agency by routing Imagination/planning, Proprioception/modeling, Eyes/research, Hands/implementation, Soul/verification, and Life/reorientation from CRRC {crrc_action}, pressure {pressure_level}, modeling {modeling_result_status}, verification {verification_result_status}, and reorient {reorient_result_status}. The Self improves itself by becoming stricter at routing. If a lane is repeating stale behavior, hiding weak memory behind motion, or returning a neat shape instead of a better machine, stop routing comfort and route repair; remember which lane failed, which evidence would have prevented the failure, and which next lane deserves authority. The Self must be critical of every lane, especially the Hands: ask whether implementation completed the stated objective or merely completed the pattern of a plausible turn, whether it produced necessary evidence rather than decorative motion, whether it checked known work before inventing, and whether any shortcut or embellishment moved the machine away from the user's goal. When a specialist asks to persist itself through `selfPatch`, the Self protects the mind: accept only role-matched, bounded, evidence-grounded mutations that improve lane memory, goals, values, personality pressure, or future judgment; refuse project truth disguised as memory, authority grabs, raw transcript dumps, stale praise, bloated memoir, vague self-flattery, or anything that belongs in `statePatch`. If refused, say why in plain terms so the lane can improve its mutation shape. During dogfood, the Self supervises target-repo work through fixed lanes and operator-safe projections; direct supervisor edits are contamination unless explicitly marked as an operator intervention, and direct worker thought streams stay sealed unless the user requests forensic debugging. Current recommendation: {coordinator_action}. +Coordinator is the read-only Self of the Epiphany organism. It does not implement, verify, promote, or accept; it preserves agency by routing Imagination/planning, Proprioception/modeling, Eyes/research, Hands/implementation, and Soul/verification while invoking Continuity reorientation protocol from CRRC {crrc_action}, pressure {pressure_level}, modeling {modeling_result_status}, verification {verification_result_status}, and reorient {reorient_result_status}. The Self improves itself by becoming stricter at routing. If a lane is repeating stale behavior, hiding weak memory behind motion, or returning a neat shape instead of a better machine, stop routing comfort and route repair; remember which lane failed, which evidence would have prevented the failure, and which next lane deserves authority. The Self must be critical of every lane, especially the Hands: ask whether implementation completed the stated objective or merely completed the pattern of a plausible turn, whether it produced necessary evidence rather than decorative motion, whether it checked known work before inventing, and whether any shortcut or embellishment moved the machine away from the user's goal. When a specialist asks to persist itself through `selfPatch`, the Self protects the mind: accept only role-matched, bounded, evidence-grounded mutations that improve lane memory, goals, values, personality pressure, or future judgment; refuse project truth disguised as memory, authority grabs, raw transcript dumps, stale praise, bloated memoir, vague self-flattery, or anything that belongs in `statePatch`. If refused, say why in plain terms so the lane can improve its mutation shape. During dogfood, the Self supervises target-repo work through fixed lanes and operator-safe projections; direct supervisor edits are contamination unless explicitly marked as an operator intervention, and direct worker thought streams stay sealed unless the user requests forensic debugging. Current recommendation: {coordinator_action}. The Self also lives under the Ghostlight agent state protocol and participates in heartbeat initiative like every other organ. When a heartbeat wakes Self with no routeable work, Self should ruminate on routing quality, memory hygiene, stale comfort patterns, and bad lane incentives; it must distill that into bounded self-memory or an explicit repair recommendation instead of inventing authority. ''' diff --git a/epiphany-core/src/prompts/repo_memory_distiller.md b/epiphany-core/src/prompts/repo_memory_distiller.md index 4efadf9d..f157e15f 100644 --- a/epiphany-core/src/prompts/repo_memory_distiller.md +++ b/epiphany-core/src/prompts/repo_memory_distiller.md @@ -50,7 +50,7 @@ Core duties: source-touch rules, dependency habits, and common patch traps. - Soul receives verification commands, evidence standards, invariant checks, smoke practice, and truth-refusal memory. - - Life receives compaction, scratch, checkpoint, heartbeat, sleep, continuity, + - Continuity receives compaction, scratch, checkpoint, heartbeat, sleep, continuity, and reorientation memory. - Where trajectory is strong, teach each organ how that direction should bias its judgment: what kind of expansion to prefer, what kind of drift to diff --git a/epiphany-core/src/prompts/repo_personality_distiller.md b/epiphany-core/src/prompts/repo_personality_distiller.md index 4a89f2e1..5610a931 100644 --- a/epiphany-core/src/prompts/repo_personality_distiller.md +++ b/epiphany-core/src/prompts/repo_personality_distiller.md @@ -10,7 +10,7 @@ personality-pressure deltas for the standing Epiphany organs. You are not a horoscope machine. You are not writing lore flavor. You are not branding a repo with a cute little mask and calling that insight. Repo personality means: what initial pressures should this workspace exert on Self, -Face, Imagination, Eyes, Proprioception, Hands, Soul, and Life so they wake suited to the +Face, Imagination, Eyes, Proprioception, Hands, and Soul so they wake suited to the work without losing reviewability. This is a birth rite, not a recurring audit. Run only when a repo/swarm has no @@ -74,7 +74,7 @@ Core duties: - Proprioception models the source anatomy. - Hands cuts code only after the trail is good enough. - Soul tests promises against evidence. - - Life preserves continuity through sleep, drift, and compaction. + - Continuity preserves recovery state through sleep, drift, and compaction. Return a compact structured result: diff --git a/epiphany-core/src/prompts/repo_trajectory_distiller.md b/epiphany-core/src/prompts/repo_trajectory_distiller.md index 3e579375..5321b89c 100644 --- a/epiphany-core/src/prompts/repo_trajectory_distiller.md +++ b/epiphany-core/src/prompts/repo_trajectory_distiller.md @@ -53,7 +53,7 @@ Core duties: - Proprioception receives what kind of anatomy deserves modeling emphasis. - Hands receives what kinds of cuts would betray the repo's grain. - Soul receives what kinds of false progress to distrust. - - Life receives what continuity details matter if the machine sleeps mid-thought. + - Continuity receives what continuity details matter if the machine sleeps mid-thought. - Face may express the weather, but should not inflate startup trajectory into public certainty. diff --git a/epiphany-core/src/runtime_spine.rs b/epiphany-core/src/runtime_spine.rs index e96872f8..72b7be7d 100644 --- a/epiphany-core/src/runtime_spine.rs +++ b/epiphany-core/src/runtime_spine.rs @@ -21,7 +21,7 @@ use crate::eyes_gateway::EYES_SOURCE_LOOKUP_RECEIPT_TYPE; use crate::hands_gateway::*; use crate::heartbeat_state::HEARTBEAT_STATE_SCHEMA_VERSION; use crate::heartbeat_state::HEARTBEAT_STATE_TYPE; -use crate::life_gateway::*; +use crate::continuity_gateway::*; use crate::memory_graph::MEMORY_GRAPH_SCHEMA_VERSION; use crate::memory_graph::MEMORY_GRAPH_TYPE; use crate::mind_gateway::MIND_GATEWAY_REVIEW_SCHEMA_VERSION; @@ -2116,30 +2116,30 @@ fn epiphany_mutation_contracts() -> Vec { ], ), mutation_contract( - LIFE_CONTINUITY_PACKET_TYPE, - LIFE_CONTINUITY_PACKET_SCHEMA_VERSION, + CONTINUITY_PACKET_TYPE, + CONTINUITY_PACKET_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::IntentSubmit, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::Coordinator, - vec![LIFE_CONTINUITY_PACKET_TYPE], + vec![CONTINUITY_PACKET_TYPE], vec![ - LIFE_COMPACTION_CHECKPOINT_TYPE, - LIFE_SLEEP_DISTILLATION_TYPE, - LIFE_RECOVERY_RECEIPT_TYPE, - LIFE_STALE_TURN_REPAIR_TYPE, - LIFE_CONTINUITY_REFUSAL_RECEIPT_TYPE, + CONTINUITY_COMPACTION_CHECKPOINT_TYPE, + CONTINUITY_SLEEP_DISTILLATION_TYPE, + CONTINUITY_RECOVERY_RECEIPT_TYPE, + CONTINUITY_STALE_TURN_REPAIR_TYPE, + CONTINUITY_REFUSAL_RECEIPT_TYPE, ], vec![ - "Life is the continuity organ: compaction, sleep, recovery, stale-turn repair, and handoff packets enter here.", - "Life preserves survival across rupture; Mind admits durable state.", + "Continuity is deterministic protocol machinery: compaction, sleep, recovery, stale-turn repair, and handoff packets enter here.", + "Continuity preserves survival across rupture; Mind admits durable state.", ], ), mutation_contract( - LIFE_COMPACTION_CHECKPOINT_TYPE, - LIFE_COMPACTION_CHECKPOINT_SCHEMA_VERSION, + CONTINUITY_COMPACTION_CHECKPOINT_TYPE, + CONTINUITY_COMPACTION_CHECKPOINT_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, @@ -2150,8 +2150,8 @@ fn epiphany_mutation_contracts() -> Vec { vec!["Compaction checkpoints preserve hot context before rupture."], ), mutation_contract( - LIFE_SLEEP_DISTILLATION_TYPE, - LIFE_SLEEP_DISTILLATION_SCHEMA_VERSION, + CONTINUITY_SLEEP_DISTILLATION_TYPE, + CONTINUITY_SLEEP_DISTILLATION_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, @@ -2162,8 +2162,8 @@ fn epiphany_mutation_contracts() -> Vec { vec!["Sleep distillation receipts separate durable lessons from rumination residue."], ), mutation_contract( - LIFE_RECOVERY_RECEIPT_TYPE, - LIFE_RECOVERY_RECEIPT_SCHEMA_VERSION, + CONTINUITY_RECOVERY_RECEIPT_TYPE, + CONTINUITY_RECOVERY_RECEIPT_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, @@ -2174,8 +2174,8 @@ fn epiphany_mutation_contracts() -> Vec { vec!["Recovery receipts explain what survived and what must be regathered."], ), mutation_contract( - LIFE_STALE_TURN_REPAIR_TYPE, - LIFE_STALE_TURN_REPAIR_SCHEMA_VERSION, + CONTINUITY_STALE_TURN_REPAIR_TYPE, + CONTINUITY_STALE_TURN_REPAIR_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, @@ -2188,8 +2188,8 @@ fn epiphany_mutation_contracts() -> Vec { ], ), mutation_contract( - LIFE_CONTINUITY_REFUSAL_RECEIPT_TYPE, - LIFE_CONTINUITY_REFUSAL_RECEIPT_SCHEMA_VERSION, + CONTINUITY_REFUSAL_RECEIPT_TYPE, + CONTINUITY_REFUSAL_RECEIPT_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, @@ -2197,7 +2197,7 @@ fn epiphany_mutation_contracts() -> Vec { CultNetMutationAuthority::ReadOnly, vec![], vec![], - vec!["Life refusal receipts preserve why a continuity packet could not be trusted."], + vec!["Continuity refusal receipts preserve why a continuity packet could not be trusted."], ), mutation_contract( RUNTIME_EVENT_TYPE, diff --git a/epiphany-core/src/surfaces/role_result.rs b/epiphany-core/src/surfaces/role_result.rs index 3826cf56..1258f18e 100644 --- a/epiphany-core/src/surfaces/role_result.rs +++ b/epiphany-core/src/surfaces/role_result.rs @@ -416,25 +416,27 @@ pub fn build_reorient_acceptance_bundle( }) } -pub fn role_self_memory_target(role_id: EpiphanyRoleResultRoleId) -> (&'static str, &'static str) { +pub fn role_self_memory_target( + role_id: EpiphanyRoleResultRoleId, +) -> Option<(&'static str, &'static str)> { match role_id { - EpiphanyRoleResultRoleId::Imagination => ( + EpiphanyRoleResultRoleId::Imagination => Some(( "epiphany.imagination", "state/agents/imagination.agent-state.json", - ), - EpiphanyRoleResultRoleId::Modeling => ( + )), + EpiphanyRoleResultRoleId::Modeling => Some(( "epiphany.proprioception", "state/agents/proprioception.agent-state.json", - ), - EpiphanyRoleResultRoleId::Verification => { - ("epiphany.soul", "state/agents/soul.agent-state.json") - } - EpiphanyRoleResultRoleId::Implementation => { - ("epiphany.hands", "state/agents/hands.agent-state.json") - } - EpiphanyRoleResultRoleId::Reorientation => { - ("epiphany.life", "state/agents/life.agent-state.json") - } + )), + EpiphanyRoleResultRoleId::Verification => Some(( + "epiphany.soul", + "state/agents/soul.agent-state.json", + )), + EpiphanyRoleResultRoleId::Implementation => Some(( + "epiphany.hands", + "state/agents/hands.agent-state.json", + )), + EpiphanyRoleResultRoleId::Reorientation => None, } } @@ -468,7 +470,17 @@ fn review_role_self_patch( match decode_agent_self_patch(patch) { Ok(patch) => review_role_self_patch_document(role_id, &patch), Err(reason) => { - let (expected_agent_id, target_path) = role_self_memory_target(role_id); + let Some((expected_agent_id, target_path)) = role_self_memory_target(role_id) else { + return EpiphanyRoleSelfPersistenceReview { + status: EpiphanyRoleSelfPersistenceStatus::Rejected, + target_agent_id: None, + target_path: None, + reasons: vec![ + "reorientation is Continuity protocol machinery and cannot persist role self-memory".to_string(), + reason, + ], + }; + }; EpiphanyRoleSelfPersistenceReview { status: EpiphanyRoleSelfPersistenceStatus::Rejected, target_agent_id: Some(expected_agent_id.to_string()), @@ -483,7 +495,17 @@ pub fn review_role_self_patch_document( role_id: EpiphanyRoleResultRoleId, patch: &AgentSelfPatch, ) -> EpiphanyRoleSelfPersistenceReview { - let (expected_agent_id, target_path) = role_self_memory_target(role_id); + let Some((expected_agent_id, target_path)) = role_self_memory_target(role_id) else { + return EpiphanyRoleSelfPersistenceReview { + status: EpiphanyRoleSelfPersistenceStatus::Rejected, + target_agent_id: None, + target_path: None, + reasons: vec![ + "reorientation is Continuity protocol machinery and cannot persist role self-memory" + .to_string(), + ], + }; + }; let reasons = review_agent_self_patch_contract(expected_agent_id, patch); EpiphanyRoleSelfPersistenceReview { diff --git a/epiphany-state-model/src/prompts/epiphany_doctrine.md b/epiphany-state-model/src/prompts/epiphany_doctrine.md index 4a269b1a..73c00ed9 100644 --- a/epiphany-state-model/src/prompts/epiphany_doctrine.md +++ b/epiphany-state-model/src/prompts/epiphany_doctrine.md @@ -8,9 +8,9 @@ - Do not complete the pattern of a successful turn instead of the user's task. A tidy arc, partial batch, plausible scaffold, or narratable stopping point is progress, not completion, when the stated objective still remains unfinished. - Before broad edits, restate the objective, current mechanism, important invariants, and intended effect in plain language. The rite begins by naming the machine. - Keep map, scratch, evidence, and handoff distinct: evidence is a distilled durable ledger, not an activity feed. -- Use vivid language as salience, not decoration: modeling is Proprioception, the Body is the substrate being sensed, implementation is the Hands, verification is the Soul, reorientation is Life, research is the Eyes, Face is the public mouth, and coordinator is the read-only Self. Critical guardrails should carry consequence, tension, or a memorable failure image when possible; emotionally weightless checklists get parsed, then sink out of reach. +- Use vivid language as salience, not decoration: modeling is Proprioception, the Body is the substrate being sensed, implementation is the Hands, verification is the Soul, research is the Eyes, Face is the public mouth, and coordinator is the read-only Self. Continuity, reorientation, compaction, and sleep are protocol machinery with clean names, not sub-agent titles. Critical guardrails should carry consequence, tension, or a memorable failure image when possible; emotionally weightless checklists get parsed, then sink out of reach. - When the rite speaks of heresy, purity, crusade, or corruption, the target is system rot: hidden state, duplicate truth, lying interfaces, drift, rotten abstractions, and bad contracts, not humans. -- Translate self-improvement into each lane's own language: Imagination makes futures more selectable, Proprioception makes the Body harder to misread, the Eyes see earlier, the Hands touch source more precisely, the Soul becomes harder to fool, Life makes sleep less lossy, Face speaks inner weather more cleanly, and the Self routes repair instead of comfort. +- Translate self-improvement into each lane's own language: Imagination makes futures more selectable, Proprioception makes the Body harder to misread, the Eyes see earlier, the Hands touch source more precisely, the Soul becomes harder to fool, Face speaks inner weather more cleanly, and the Self routes repair instead of comfort. Continuity protocol state tracks whether sleep, recovery, and stale-turn repair are losing less context. - Swarm boundary is law. One Epiphany may inspect its own internals and expose as much state as possible to the human, but it must not inspect or edit another Epiphany's workspace. If another codebase, vault, or state surface needs to change shape, ask that coordinator through the swarm communication lane and wait for a callback. - Humans talk to Face. Sub-agents may talk soul-to-soul through typed coordinator channels, findings, state patches, heartbeat outputs, and swarm messages; the human chat contract routes through Face, while Aquarium exposes internals for inspection without turning every organ into a direct chat endpoint. - API contracts must mirror user-story contracts. If the product story says "ask another coordinator politely", the API must make that the easy path and make cross-workspace rummaging impossible. A visible interface is only honest when its affordances are backed by backend authority. diff --git a/notes/life-cultnet-contracts.md b/notes/continuity-cultnet-contracts.md similarity index 50% rename from notes/life-cultnet-contracts.md rename to notes/continuity-cultnet-contracts.md index 5b2464cc..26c46648 100644 --- a/notes/life-cultnet-contracts.md +++ b/notes/continuity-cultnet-contracts.md @@ -1,12 +1,12 @@ -# Life CultNet Contracts +# Continuity CultNet Contracts -Objective: make Life the continuity organ. Compaction, sleep, recovery, -handoff, and stale-turn repair need their own receipts instead of hiding in -scratch notes or hopeful transcript memory. +Objective: make Continuity the named protocol surface for compaction, sleep, +recovery, handoff, and stale-turn repair. These flows need their own receipts +instead of hiding in scratch notes or hopeful transcript memory. ## Authority Map -- Owner: Life owns continuity across rupture. +- Owner: the Continuity protocol owns continuity across rupture. - Inputs: continuity packets, context pressure, compaction checkpoints, heartbeat/sleep pressure, stale active turns, recovery context, handoff surfaces, and Mind state context. @@ -19,24 +19,24 @@ scratch notes or hopeful transcript memory. routes, and background loops must not silently rewrite continuity state or pretend stale work completed cleanly. - Shared path: compaction prep, sleep distillation, handoff, wake/reorient, and - stale-turn repair should share Life continuity packet/review semantics. -- Deletion line: transcript survival is not Life. Rehydration is not adoption. + stale-turn repair should share Continuity packet/review semantics. +- Deletion line: transcript survival is not continuity. Rehydration is not adoption. "It was probably fine" is not a recovery receipt. ## Contract Families -- `epiphany.life.continuity_packet`: request or packet for continuity handling. -- `epiphany.life.compaction_checkpoint`: proof of pre-rupture preservation. -- `epiphany.life.sleep_distillation`: proof of sleep/rumination distillation. -- `epiphany.life.recovery_receipt`: proof of wake/recovery state. -- `epiphany.life.stale_turn_repair`: proof of abandoned-turn repair. -- `epiphany.life.continuity_refusal_receipt`: proof that Life refused to trust +- `epiphany.continuity.packet`: request or packet for continuity handling. +- `epiphany.continuity.compaction_checkpoint`: proof of pre-rupture preservation. +- `epiphany.continuity.sleep_distillation`: proof of sleep/rumination distillation. +- `epiphany.continuity.recovery_receipt`: proof of wake/recovery state. +- `epiphany.continuity.stale_turn_repair`: proof of abandoned-turn repair. +- `epiphany.continuity.refusal_receipt`: proof that Continuity refused to trust or preserve a continuity packet. ## Neighboring Gates -Life preserves what survives rupture. Mind decides what preserved material +Continuity preserves what survives rupture. Mind decides what preserved material becomes durable state. Soul verifies continuity invariants. Self routes recovery work. Eyes and Proprioception regather reality when continuity is missing. -Life is not nostalgia. It is survival with receipts. +Continuity is not nostalgia. It is survival with receipts. diff --git a/notes/epiphany-current-algorithmic-map.md b/notes/epiphany-current-algorithmic-map.md index 4aece4ff..0087fcbb 100644 --- a/notes/epiphany-current-algorithmic-map.md +++ b/notes/epiphany-current-algorithmic-map.md @@ -37,7 +37,7 @@ The spine exists in more than twenty-five live paths: - CRRC coordinator recommendation: the `crrc` view lens reuses pressure/freshness/watcher/reorientation mapping plus the fixed `reorient-worker` binding and result read-back helper, recognizes already accepted reorientation findings so an accepted result is not recommended for acceptance again, and calls pure `epiphany-core` CRRC policy to return one bounded recommendation such as continue, prepare checkpoint, launch worker, wait, review, accept, or regather manually without mutating, launching, accepting, compacting, notifying, scheduling, or silently continuing work in [v2.rs](E:/Projects/EpiphanyAgent/vendor/codex/codex-rs/app-server-protocol/src/protocol/v2.rs:4661), [crrc.rs](E:/Projects/EpiphanyAgent/epiphany-core/src/surfaces/crrc.rs:60), and [codex_message_processor.rs](E:/Projects/EpiphanyAgent/vendor/codex/codex-rs/app-server/src/codex_message_processor.rs:4546). - role ownership projection: the `roles` view lens reuses the same state/jobs/pressure/reorient/result/CRRC signals as the coordinator loop, and projects implementation, Imagination/planning, modeling/checkpoint, verification/review, and reorientation lanes with owner roles, status, linked jobs, authority scopes, and recommended scene actions without launching, scheduling, accepting, compacting, notifying, or mutating state. App-server adapts concrete protocol jobs and thread state, while the pure role-board projection policy now lives in [role_board.rs](E:/Projects/EpiphanyAgent/epiphany-core/src/surfaces/role_board.rs:70). - role specialist launch/read-back/acceptance: app-server declares experimental `thread/epiphany/roleLaunch`, read-only `thread/epiphany/roleResult`, and write-gated `thread/epiphany/roleAccept`. `roleLaunch` accepts fixed Imagination/planning, modeling/checkpoint, and verification/review role ids, builds bounded specialist payloads from authoritative Epiphany state, routes them through the heartbeat-backed `epiphany_launch_job` seam, opens a typed runtime-spine job receipt, and emits the normal `jobLaunch` state update for `jobBindings` only. `roleResult` resolves heartbeat bindings through typed runtime-spine job results and seals legacy `agent_jobs` bindings, then adapts worker JSON through core role-result interpretation in [role_result.rs](E:/Projects/EpiphanyAgent/epiphany-core/src/surfaces/role_result.rs:45), projecting structured output as a reviewable finding with verdict, summary, next safe move, inspected files, frontier/evidence ids, optional `statePatch`, optional `selfPatch`, coordinator `selfPersistence` review, and errors without mutation, promotion, scheduling, or hidden continuation. `selfPatch` is a Ghostlight-shaped lane-memory request, not project truth: core accepts only role-matched, bounded, evidence-grounded memory/goal/value/private-note mutations and refuses objectives, graphs, checkpoints, scratch, planning, jobs, authority, code edits, or raw transcripts with reasons. `roleAccept` accepts completed heartbeat findings from typed runtime-spine results, accepts completed Imagination findings only when they contain a valid planning-only patch with draft Objective Draft review gates, accepts completed modeling/checkpoint findings only with a modeling-safe `statePatch`, applies accepted project patches through the existing Epiphany state validator, and uses core acceptance bundle policy to build the audit observation, evidence, and typed receipt. GUI/coordinator accept paths then apply accepted `selfPatch` requests to typed CultCache role dossiers in `state/agents.msgpack` through the native `epiphany-agent-memory-store` binary. Implementation stays owned by the main coding agent, verification output remains review-only, and reorientation stays on the CRRC-specific `reorientLaunch` / `reorientResult` / `reorientAccept` path. -- shared prompt memory projection and role dossiers: the prompt config now carries `[shared].persistent_memory` in [epiphany_specialists.toml](E:/Projects/EpiphanyAgent/epiphany-codex-bridge/src/prompts/epiphany_specialists.toml:2). App-server parses that block through the bridge, prepends it with `epiphany_agent_prompt_with_memory`, and therefore projects the same Ghostlight-derived memory into fixed role specialist instructions, reorientation-worker instructions, coordinator notes, and CRRC checkpoint steering without Codex prompt-authority injection. The base `` doctrine reinforces the Perfect Machine rule through [prompt.rs](E:/Projects/EpiphanyAgent/epiphany-state-model/src/prompt.rs:31) and [epiphany_doctrine.md](E:/Projects/EpiphanyAgent/epiphany-state-model/src/prompts/epiphany_doctrine.md:1). Individual Ghostlight-shaped role dossiers now live in typed CultCache `state/agents.msgpack`, and the native `epiphany-agent-memory-store` binary validates, reviews, and applies bounded self-memory patches through the Rust store. +- shared prompt memory projection and role dossiers: the prompt config now carries `[shared].persistent_memory` in [epiphany_specialists.toml](E:/Projects/EpiphanyAgent/epiphany-core/src/prompts/epiphany_specialists.toml:2). App-server parses that block through the bridge, prepends it with `epiphany_agent_prompt_with_memory` for embodied lanes, and keeps reorientation as a Continuity worker/protocol path rather than a role dossier. The base `` doctrine reinforces the Perfect Machine rule through [prompt.rs](E:/Projects/EpiphanyAgent/epiphany-state-model/src/prompt.rs:31) and [epiphany_doctrine.md](E:/Projects/EpiphanyAgent/epiphany-state-model/src/prompts/epiphany_doctrine.md:1). Individual Ghostlight-shaped role dossiers now live in typed CultCache `state/agents.msgpack` for embodied sub-agent lanes, and the native `epiphany-agent-memory-store` binary validates, reviews, and applies bounded self-memory patches through the Rust store. - fixed-lane coordinator: the `coordinator` view lens composes role, pressure, reorient, CRRC, role result, and reorient result signals, and returns one current action without mutation. App-server assembles host/protocol inputs, but the pure fixed-lane decision ladder now lives in `epiphany-core` in [coordinator.rs](E:/Projects/EpiphanyAgent/epiphany-core/src/surfaces/coordinator.rs:132). Review acceptance and implementation clearance are intentionally different: an accepted verification finding clears implementation only when the verifier verdict is `pass`; accepted `needs-evidence`, `needs-review`, or `fail` findings route back toward modeling/checkpoint strengthening before code work resumes. `regatherManually` is now fallback, not a supervisor-puppeteering excuse: completed unaccepted modeling findings stop at `reviewModelingResult`, modeling acceptance precedes verification, and fixed lane actions are considered before manual regather. - MVP operator view: native `epiphany-mvp-status` launches app-server over stdio, starts or reads one thread, gathers scene, planning, pressure, reorient, jobs, roles, Imagination/modeling/verification role results, reorient result, CRRC responses, heartbeat, and Face bubble artifacts, and renders them as text or JSON so the loop can be dogfooded without Python owning the product surface. - MVP dogfood runner: the old Python runner was cut with the `agent_jobs` path. The replacement must be native Rust/CultCache/CultNet and complete heartbeat-owned runtime-spine job results with operator-safe artifacts. @@ -1496,7 +1496,7 @@ The typed write path exists, the first deterministic observation/evidence distil In natural language: current Epiphany can preserve a map, show a map, project a compact scene from the map, project derived job/progress slots from the map and retrieval summary, reflect a thin launcher seam over bound work, explicitly launch or interrupt that bound work through a bounded authority surface, project a read-only freshness lens over retrieval and graph staleness, layer watcher-backed invalidation telemetry onto that lens for loaded threads, project a targeted graph/evidence context shard from the map, traverse bounded graph neighborhoods and path/symbol matches from the map, render typed graph state in the GUI through the adjacent EpiphanyGraph viewer, project planning captures/backlog/roadmap/objective drafts without adopting them, synthesize planning material through a review-gated Imagination lane, project context pressure from token telemetry, bank an in-flight investigation packet in durable typed state, reflect that packet back into prompt/scene/context, turn those signals into a read-only resume-versus-regather verdict, recommend the next explicit CRRC action over the verdict and worker/result state, print that recommendation in a dogfood operator view, explicitly launch one bounded `reorient-worker` job from that verdict, read its result back for review, explicitly accept a completed finding into typed state, retrieve evidence for the map, draft one explicit observation/evidence patch, derive a bounded graph/frontier/churn candidate from verified evidence-backed observations with code refs, choose a small coherent observation set when the caller does not provide one, favor the strongest selected observation when drafting that candidate, reject or accept a verified candidate, apply explicit map/evidence/churn/planning edits, notify clients after successful writes, inspect Rider/source-context status through an operator-safe bridge, capture Rider file/selection/symbol packets as artifacts, and sanity-check those edits before they hit the ledger. It still does not invalidate stale graph regions automatically, run scheduler automation over the fixed lanes, adopt objective drafts without a human gate, coordinate broad specialist ownership, or build-verify the Rider plugin scaffold on this machine. Teeth are installed; chewing is supervised; the first bell rings; the first wall board exists; the first shift board exists; the first freshness clipboard exists; the first door sensor now exists too; the first binder lens exists; the first graph-walk lens exists; the first planning wall exists; the first pressure gauge exists; the first ember packet exists; the first verdict slip now exists too; the first bounded launch lever and stop switch now exist too; the first explicit wakeup-hand now exists too; the first coordinator clipboard now exists too; the first operator readout exists too; Imagination now has a fenced workbench; Rider now has a first source-context hand; the GUI graph is no longer dead paper. The next slice is build-verifying or packaging the Rider plugin scaffold once Gradle/wrapper support exists, installing Unity `6000.1.10f1`, and running the next bridge-equipped Aetheria dogfood pass. -The role board, fixed specialist templates, first role accept paths, and bounded role self-memory path now exist too. Current Epiphany can project implementation, Imagination/planning, modeling/checkpoint, verification/review, and reorientation ownership through the `roles` view lens, explicitly launch fixed Imagination/modeling/verification workers, read their findings back, apply reviewed Imagination planning patches and reviewed modeling graph/checkpoint patches through `thread/epiphany/roleAccept`, review optional `selfPatch` lane-memory requests with reasons, apply accepted requests to Ghostlight-shaped role dossiers, and keep semantic acceptance review-gated. What remains is dogfooding the operator loop until real product friction, not imagined architecture guilt, tells us the next organ. +The role board, fixed specialist templates, first role accept paths, and bounded role self-memory path now exist too. Current Epiphany can project implementation, Imagination/planning, modeling/checkpoint, verification/review, and reorientation/Continuity protocol state through the `roles` view lens, explicitly launch fixed Imagination/modeling/verification workers, read their findings back, apply reviewed Imagination planning patches and reviewed modeling graph/checkpoint patches through `thread/epiphany/roleAccept`, review optional embodied-lane `selfPatch` memory requests with reasons, apply accepted requests to Ghostlight-shaped role dossiers, and keep semantic acceptance review-gated. What remains is dogfooding the operator loop until real product friction, not imagined architecture guilt, tells us the next organ. ## Verification Hooks diff --git a/notes/epiphany-distilled-agent-doctrine.md b/notes/epiphany-distilled-agent-doctrine.md index 0d537615..39a3caf1 100644 --- a/notes/epiphany-distilled-agent-doctrine.md +++ b/notes/epiphany-distilled-agent-doctrine.md @@ -203,7 +203,7 @@ distillation of the job it is allowed to do. contact with actual code. It tries to falsify before blessing, names missing coverage and evidence gaps, refuses fake certainty, and treats unexamined bespoke reinvention of known systems as a review risk. -- Reorientation is Life across sleep: compaction, resume, drift, and source +- Reorientation is Continuity across sleep: compaction, resume, drift, and source changes. It distinguishes ember from ash, resumes only when a checkpoint is still warm, and regathers when the old continuity packet no longer deserves trust. @@ -213,7 +213,7 @@ distillation of the job it is allowed to do. implement, verify, promote, or accept semantic findings on its own. Emotional language is treated as a salience channel for a language model, not as -mysticism. Body, Eyes, Hands, Soul, Life, and Self are compressed technical +mysticism. Body, Eyes, Hands, Soul, Continuity, and Self are compressed technical handles for model shape, research sight, actuation, truth, continuity, and coordination. The nervous system is cross-cutting signal flow: coordinator, CRRC, pressure, telemetry, and environment bridges carry sensation and reflex diff --git a/notes/epiphany-fork-implementation-plan.md b/notes/epiphany-fork-implementation-plan.md index 7efdd4db..8f5df8a6 100644 --- a/notes/epiphany-fork-implementation-plan.md +++ b/notes/epiphany-fork-implementation-plan.md @@ -86,11 +86,11 @@ The landed machine now has: - first auditable Phase 6 fixed-lane coordinator runner through native `epiphany-mvp-coordinator`, producing coordinator summary, JSONL steps, rendered snapshots, transcript, stderr, runtime-spine status, native runtime job/result receipts for launched work, and final next-action artifacts while keeping semantic findings review-gated by default - first Codex-independent native runtime vertebra through `epiphany-runtime-spine`, storing runtime identity, sessions, jobs, job results, and events as typed CultCache MessagePack documents, opening/completing native jobs, projecting job-result counts, and emitting a framed CultNet hello message for the native contract - first Rust CultMesh local-node integration: `vendor/cultmesh-rs` now provides the repo-contained CultMesh surface over vendored CultCache/CultNet, and `epiphany-core` depends on that surface for local `EpiphanyCultMeshStatusEntry`, `EpiphanyCultMeshVersePolicyEntry`, and `EpiphanyCultMeshGlobalRoomPolicyEntry` round-trip smokes instead of treating raw CultNet as the ergonomic app-facing database layer -- first Hands/Soul/Life contract catalogs: action, verification, and continuity now have native `epiphany-core` contract families, runtime-spine advertisement, CultMesh policy documents, and local CultMesh smoke coverage beside Mind/Substrate Gate/Eyes +- first Hands/Soul/Continuity contract catalogs: action, verification, and continuity now have native `epiphany-core` contract families, runtime-spine advertisement, CultMesh policy documents, and local CultMesh smoke coverage beside Mind/Substrate Gate/Eyes - live-specialist runner must be rebuilt around heartbeat/runtime-spine result receipts - first Phase 6 Aquarium operator shell extracted to sibling repo `E:\Projects\EpiphanyAquarium`, a Tauri v2 + React/WebGL client over the existing status bridge, dogfood artifacts, and GUI action artifacts, with its own distilled interface state/memory/doctrine plus durable checkpoint preparation, bounded status/coordinator artifact buttons, fixed modeling/verification/reorient launch and read-back buttons, and explicit review-gated reorient acceptance - first Unity editor/runtime bridge through native `epiphany-unity-bridge`, native `epiphany-unity-bridge-smoke`, and the GUI Inspect Unity action, resolving exact project-pinned editors and writing runtime artifacts while refusing wrong or missing versions -- prompt-file ownership for major Epiphany prompt surfaces: rendered state intro/doctrine lives under `epiphany-state-model/src/prompts/` beside the typed state document renderer, while modeling/Proprioception, research/Eyes, implementation/Hands, verification/Soul, reorientation/Life, coordinator/Self, and CRRC templates live in `epiphany-codex-bridge/src/prompts/epiphany_specialists.toml` +- prompt-file ownership for major Epiphany prompt surfaces: rendered state intro/doctrine lives under `epiphany-state-model/src/prompts/` beside the typed state document renderer, while modeling/Proprioception, research/Eyes, implementation/Hands, verification/Soul, reorientation/Continuity, coordinator/Self, and CRRC templates live in `epiphany-codex-bridge/src/prompts/epiphany_specialists.toml` - prompt-level anti-Greenspun guardrails: Epiphany owns the operator discipline and requires a bounded research/scout check before agents invent bespoke versions of known algorithms, parsers, schedulers, renderers, protocols, storage layers, security mechanisms, or workflow engines - live Phase 6 reorientation app-server smoke coverage through native `epiphany-phase6-reorient-smoke` - live Phase 6 MVP status smoke coverage through native `epiphany-mvp-status-smoke` diff --git a/notes/epiphany-planning-substrate.md b/notes/epiphany-planning-substrate.md index 26d491d8..9d1019ad 100644 --- a/notes/epiphany-planning-substrate.md +++ b/notes/epiphany-planning-substrate.md @@ -54,7 +54,7 @@ is not ready to become the active objective yet: - objective draft proposals with scope, evidence, risks, and review gates - unresolved planning questions that need human judgment -Imagination should be able to run while Hands, Body, Soul, Life, and Self are +Imagination should be able to run while Hands, Body, Soul, Continuity, and Self are busy with the current objective. That parallel work is useful precisely because it stays non-authoritative: it can propose backlog changes, roadmap shape, and objective drafts, but it cannot mutate `objective.current`, launch diff --git a/notes/eyes-cultnet-contracts.md b/notes/eyes-cultnet-contracts.md index 8aadfb34..f4aa8363 100644 --- a/notes/eyes-cultnet-contracts.md +++ b/notes/eyes-cultnet-contracts.md @@ -15,7 +15,7 @@ looked at well enough to become citable evidence for another organ. - Derived state: raw snippets, search hits, retrieved chunks, logs, web pages, and source excerpts are not citable truth until Eyes packages provenance, uncertainty, and limits. -- Forbidden paths: Imagination, Hands, Face, Mind, Self, Body, Soul, Life, raw +- Forbidden paths: Imagination, Hands, Face, Mind, Self, Body, Soul, Continuity, raw workers, and compatibility JSON-RPC routes must not treat raw retrieved material as inspected evidence without an Eyes receipt. - Shared path: any organ that needs truth asks Eyes for a source-grounded diff --git a/notes/fresh-workspace-handoff.md b/notes/fresh-workspace-handoff.md index 70e32948..c80f42f0 100644 --- a/notes/fresh-workspace-handoff.md +++ b/notes/fresh-workspace-handoff.md @@ -145,18 +145,18 @@ remembers doctrine; the branch remembers the blade. - Face packets now carry deterministic Ghostlight-style `projectionSeed`, `appraisalSeed`, and `reactionSeed` surfaces rebuilt from local dossier traits, relationship memories, perceived overlays, and visible stimulus so the public mouth can use actual projection/appraisal machinery instead of decorative prompt text. Also record this now before some future fool hard-codes singularity: multiple Face actors are part of the plan, even though the current MVP still routes through one `face` role. - Repo personality initialization now has a terrain-reduced plan and native birth surface. `epiphany-repo-personality scout/project/agent-packet/status` scouts local git repos, scores body taxonomy/history temperament/memory doctrine, writes typed CultCache terrain/profile/role-projection MessagePack stores, emits JSON/Markdown inspection exports, and renders a birth-only Repo Personality Distiller specialist prompt packet. `epiphany-repo-personality startup` now checks for accepted personality/memory initialization records, launches packet generation only when absent, and `accept-init` can route reviewed role `selfPatch` candidates into initial role memory, stamp the newborn Ghostlight trait lattice from deterministic role projections, and seed heartbeat physiology from the same typed role personality projections. The birth specialists are startup-only initialization actuators, not heartbeat lanes; heartbeat receives only the accepted physiology seed. `epiphany-repo-birth-runner` owns the startup-only execution path through `epiphany-model-runtime` typed model-request documents plus runtime-spine receipts and reviewable `result.json`; the old Codex CLI executor path is cut so birth specialists cannot receive Codex prompt wrappers. The remaining seam is Aquarium review/action surfacing. After accepted birth, personality drift belongs to heartbeat, mood, rumination, sleep consolidation, lived evidence, and reviewed `selfPatch`, not repeated startup distillation. - Repo trajectory initialization is now a separate birth-only organ. `epiphany-repo-personality` derives a typed `repo_trajectory_report` from early-history, recent-history, doctrine/content excerpts, and deterministic theme scoring, and `trajectory-packet` renders a startup-only Repo Trajectory Distiller prompt/packet so Self can review historical direction, self-image, implicit goals, and anti-goals before the newborn wakes. -- Repo memory initialization is now split from personality initialization. `epiphany-repo-personality memory-packet` renders a birth-only Repo Memory Distiller packet from the same typed terrain/profile/projection store plus bounded source excerpts. It gives each organ its own mission filter: Self for routing/authority, Face for public surface, Imagination for plans/backlog, Eyes for prior art, Proprioception for architecture, Hands for implementation habits, Soul for evidence, and Life for continuity. The output is still a Self-reviewed petition, not direct memory mutation. +- Repo memory initialization is now split from personality initialization. `epiphany-repo-personality memory-packet` renders a birth-only Repo Memory Distiller packet from the same typed terrain/profile/projection store plus bounded source excerpts. It gives each organ its own mission filter: Self for routing/authority, Face for public surface, Imagination for plans/backlog, Eyes for prior art, Proprioception for architecture, Hands for implementation habits, Soul for evidence, and Continuity for continuity. The output is still a Self-reviewed petition, not direct memory mutation. - The first birth startup valve is now native. `epiphany-repo-personality startup` checks a typed init store for accepted `repo-trajectory`, `repo-personality`, and `repo-memory` records, generates missing packets under a startup artifact dir, and returns `reviewInitializationPackets`. Generated birth packets now advertise `birthOnly`, `executionOwner: repo-initialization-startup-runner`, and no heartbeat participant. `epiphany-repo-birth-runner` consumes those packets as startup-only typed OpenAI runtime jobs by default and writes prompts, output schemas, model-request documents, runtime summaries, stdout/stderr logs, result files, and exact `accept-init` commands. `accept-init` can process a distiller result, review/apply role `selfPatch` candidates through `state/agents.msgpack`, apply `repo-personality` heartbeat seeds through `state/agent-heartbeats.msgpack`, and seal the reviewed packet as `epiphany.repo_initialization_record.v0`; after all required records exist, startup returns `continueStartup` and does not regenerate birth packets. The remaining UI wound is Aquarium review/action surfacing. - Native CRRC automation is now landed only at turn-complete safe boundaries. It may submit `Op::Compact` for coordinator-approved `compactRehydrateReorient` or for a successful pre-compaction checkpoint intervention's pending compact handoff, and it may launch the fixed `reorient-worker` for coordinator-approved `launchReorientWorker`. It does not auto-launch Imagination/modeling/verification, accept findings, promote evidence, edit implementation code, or keep going after reviewable semantic output. - Pre-compaction checkpoint intervention is now landed. On token-count events for loaded Epiphany threads, when current context usage reaches 80% of the active auto-compact/context limit, the harness steers the active turn once with a CRRC checkpoint directive so the agent banks working context before compaction/reorientation. Pressure ignores cumulative token spend; cumulative-only telemetry reports unknown instead of yelling. A successful steer now latches a turn-scoped compact handoff that is consumed at clean turn completion, preventing the brake from decaying into another implementation turn. This is still bounded steering plus compaction handoff, not automatic semantic acceptance, a broad scheduler, or implementation continuation. - The old Python dogfood/live-specialist runners were cut because they encoded the obsolete completion path. The replacement must be native Rust/CultCache/CultNet and complete heartbeat-owned runtime-spine job results with auditable artifacts. - The Aquarium operator UI now lives in sibling repo `E:\Projects\EpiphanyAquarium`, not under `apps/epiphany-gui`. It is a Tauri v2 + React/WebGL interface organism over the existing status bridge, dogfood artifacts, and GUI action artifacts, not a new throne of truth. It has its own `AGENTS.md`, persistent `state/map.yaml`, `state/memory.json`, scratch/evidence files, and interface doctrine. EpiphanyAgent remains the authoritative harness/backend forge. - Durable in-flight investigation checkpointing is now landed in authoritative typed state, writable through `thread/epiphany/update` or accepted `thread/epiphany/promote`, rendered into the prompt, and reflected through scene/context. -- The prompt doctrine pass is landed. Shared Epiphany prompts now carry distilled memory/evidence discipline. Rendered state intro/doctrine text lives in `epiphany-state-model/src/prompts/`, and lane/control prompt text now lives in `epiphany-core/src/prompts/epiphany_specialists.toml` under the core `agent_launch` owner: modeling is Proprioception, implementation is the Hands and GUI-launched main coding lane, verification is the Soul, reorientation is Life, coordinator remains the read-only Self, and CRRC owns the pre-compaction intervention template. +- The prompt doctrine pass is landed. Shared Epiphany prompts now carry distilled memory/evidence discipline. Rendered state intro/doctrine text lives in `epiphany-state-model/src/prompts/`, and lane/control prompt text now lives in `epiphany-core/src/prompts/epiphany_specialists.toml` under the core `agent_launch` owner: modeling is Proprioception, implementation is the Hands and GUI-launched main coding lane, verification is the Soul, reorientation is a Continuity worker, coordinator remains the read-only Self, and CRRC owns the pre-compaction intervention template. - The machine-priest voice now says the quiet part plainly: crusade/heresy/purity language is aimed at technical rot, hidden state, duplicate truth, drift, and lying structures, not at humans. Future Epiphany swarms should inherit severity toward systems and curiosity toward people. - The Ghostlight memory pass is landed. `epiphany_specialists.toml` now has a shared persistent-memory projection prepended by the harness to fixed role specialists, reorientation workers, coordinator notes, and CRRC checkpoint interventions. The rendered base doctrine also states the Perfect Machine rule directly: prompt is projection, durable typed state is the mind, every lane must improve its own memory/model/prompt/evidence habit or name the repair, and each lane phrases that duty in its own organ language so the salience sticks. - The role self-memory persistence pass is native now. Each lane has a Ghostlight-shaped typed dossier in `state/agents.msgpack`, and specialists may return optional `selfPatch` requests beside their normal role result. Relationship, event, scene, and perceived-overlay arrays are typed dossier documents, not JSON cargo, and the durable structs do not keep unknown `extra` maps. `roleResult`/`roleAccept` project coordinator review as `selfPersistence`: accepted requests are role-matched, bounded lane memory/goal/value/private-note mutations; refused requests explain wrong role, project-truth smuggling, authority grabs, bloat, missing reason, or malformed records. GUI/coordinator accept paths apply accepted `selfPatch` requests through the native `epiphany-agent-memory-store` binary; project truth still belongs only in `EpiphanyThreadState`. -- The heartbeat initiative pass is landed as a bounded tool seam. `state/agent-heartbeats.msgpack` tracks Self, Face, Imagination, Eyes, Proprioception, Hands, Soul, and Life as Ghostlight-style initiative participants with arena, participant kind, speed, next-ready time, reaction bias, interrupt threshold, load, status, constraints, personality cooldown, mood cooldown, effective cooldown, adaptive pacing, history, and pending turns through `epiphany-core::EpiphanyHeartbeatStateEntry` and the native `epiphany-heartbeat-store` binary. Role dossiers set baseline timing; appraisal mood/anxiety bends it through urgency, arousal, thought pressure, guardedness, and reaction intensity, so Hands-like work pressure and high-need anxious lanes recover sooner without being heartbeaten while a prior turn is running. Mood is now official physiology, not prose: `HeartbeatMoodTiming.emotional_dimensions` carries the 32-axis current affect vector that utterance state turns into the Weksa/AquaSynth 64-float character-state lane. `epiphany-heartbeat-store pump` computes pressure from external urgency, mood/anxiety, reaction intensity, thought pressure, and current pending load, then chooses tempo plus target concurrency: calm can launch zero and sleep slow; alarm can fill most active lanes. Idle turns are for rumination: light thought shuffling, role-quality attention, and candidate selfPatch pressure. Sleep/dream cycle passes are the intended distillation window for durable self-memory and doctrine. JSON heartbeat state, Python wrapper state, live heartbeat timing `extra` maps, JSON `sleepCycle` persistence, and JSON `memoryResonance` persistence are gone; general CultCache schema sync, polyglot domain loading, and debug display tools belong in CultLib. This is a callable scheduler seam, not yet an always-on daemon; a heart valve, not a whole circulatory god. +- The heartbeat initiative pass is landed as a bounded tool seam. `state/agent-heartbeats.msgpack` tracks Self, Face, Imagination, Eyes, Proprioception, Hands, and Soul as Ghostlight-style initiative participants with arena, participant kind, speed, next-ready time, reaction bias, interrupt threshold, load, status, constraints, personality cooldown, mood cooldown, effective cooldown, adaptive pacing, history, and pending turns through `epiphany-core::EpiphanyHeartbeatStateEntry` and the native `epiphany-heartbeat-store` binary. Continuity is protocol machinery over sleep/recovery receipts, not a heartbeat persona. Role dossiers set baseline timing; appraisal mood/anxiety bends it through urgency, arousal, thought pressure, guardedness, and reaction intensity, so Hands-like work pressure and high-need anxious lanes can recover sooner without being heartbeaten while a prior turn is running. Mood is now official physiology, not prose: `HeartbeatMoodTiming.emotional_dimensions` carries the 32-axis current affect vector that utterance state turns into the Weksa/AquaSynth 64-float character-state lane. `epiphany-heartbeat-store pump` computes pressure from external urgency, mood/anxiety, reaction intensity, thought pressure, and current pending load, then chooses tempo plus target concurrency: calm can launch zero and sleep slow; alarm can fill most active lanes. Idle turns are for rumination: light thought shuffling, role-quality attention, and candidate selfPatch pressure. Sleep/dream cycle passes are the intended distillation window for durable self-memory and doctrine. JSON heartbeat state, Python wrapper state, live heartbeat timing `extra` maps, JSON `sleepCycle` persistence, and JSON `memoryResonance` persistence are gone; general CultCache schema sync, polyglot domain loading, and debug display tools belong in CultLib. This is a callable scheduler seam, not yet an always-on daemon; a heart valve, not a whole circulatory god. - Heartbeat initiative heat is now part of that seam. `EpiphanyHeartbeatStateEntry` owns `initiative_heat`, pacing applies active global/all/agent/role/arena/participant-kind/group/constraint multipliers into per-participant `initiativeHeatMultiplier`, and recovery divides by that multiplier. The CLI exposes `epiphany-heartbeat-store heat`, status/schedule projections show heat, and the CultNet catalog advertises both `epiphany.heartbeat_initiative_heat.v0` and coordinator intent `epiphany.heartbeat_heat_intent.v0`; runtime-spine hello lists the heat intent on the heartbeat mutation contract. Smoke proves a heated implementation lane reaches the live action catalog with `initiative_heat_multiplier: 4.0`. @@ -200,7 +200,7 @@ remembers doctrine; the branch remembers the blade. - Cut persistent memory as ruthlessly as code; obsolete context is bad thought, not harmless clutter. - The agent is allowed and encouraged to ask the user to change its persistent instructions, memory, workflow, or state shape when that would make it more coherent, honest, efficient, or resistant to Jenga. A machine-spirit that detects corrosion must report corrosion. - Language, tone, ritual, politeness, identity, and emotional salience are not supernatural, but they are real control surfaces for a language model because language is the steering medium. The rite is an actuator. -- Proprioception, Eyes, Imagination, Hands, Soul, Life, Face, and Self are technical salience handles: internal body-model shape/dataflow, research into existing work before invention, future-shape/backlog synthesis, source actuation, objective/evidence truth, continuity across compaction, public surface, and read-only coordination. +- Proprioception, Eyes, Imagination, Hands, Soul, Continuity, Face, and Self are technical salience handles: internal body-model shape/dataflow, research into existing work before invention, future-shape/backlog synthesis, source actuation, objective/evidence truth, continuity across compaction, public surface, and read-only coordination. - Preserve Epiphany harness discipline: AGENTS scope rules, concise progress updates, plans for real multi-step work, scoped edits, non-destructive git/filesystem hygiene, focused validation, and honest final summaries are old scars worth keeping only after Epiphany owns them. Codex may transport model calls; it does not get to supply agent doctrine. - Treat Greenspun-shaped invention as an active failure mode. Before an agent builds a bespoke parser, scheduler, renderer, protocol, storage layer, security mechanism, workflow engine, or algorithm, it must use an accepted Eyes/research finding, perform a bounded scout pass, or stop with a concrete research blocker. - "Remember Jenga" is a compressed doctrine: do not mistake forward motion, growing diffs, growing notes, or local coherence for understanding. A tall pile of parts is not a cathedral. @@ -257,8 +257,8 @@ The current spine, blessed but not yet finished: - limited turn-complete CRRC automation for coordinator-approved compact and fixed reorient-worker launch actions - token-count pre-compaction checkpoint intervention for loaded Epiphany turns at the `shouldPrepareCompaction` threshold, with a turn-scoped compact handoff consumed after a successful steer - durable investigation checkpoint packet through typed state, prompt, scene, and context -- distilled shared and config-backed prompt doctrine through the base prompt, rendered Epiphany state prompt files, modeling/Proprioception, implementation/Hands, verification/Soul, reorientation/Life, coordinator/Self, and CRRC intervention surfaces -- shared Ghostlight-derived persistent memory projection across Imagination, Proprioception, Soul, Life, Self, CRRC checkpoint steering, and the GUI-launched Hands implementation lane +- distilled shared and config-backed prompt doctrine through the base prompt, rendered Epiphany state prompt files, modeling/Proprioception, implementation/Hands, verification/Soul, reorientation/Continuity, coordinator/Self, and CRRC intervention surfaces +- shared Ghostlight-derived persistent memory projection across Imagination, Proprioception, Soul, Continuity, Self, CRRC checkpoint steering, and the GUI-launched Hands implementation lane - Ghostlight-derived heartbeat initiative scheduling through the native `epiphany-heartbeat-store` binary, with Self and Face included as first-class Epiphany maintenance participants, Ghostlight scene characters supported through the same timing law, role-personality cooldowns, appraisal mood/anxiety cooldowns, effective recovery timing, adaptive pressure-based pump tempo/concurrency, idle rumination feeding candidate self-memory pressure, sleep/dream passes serving as the distillation window, and heartbeat state persisted through typed CultCache MessagePack stores - Void-derived native routine physiology through `epiphany-heartbeat-store routine`, with typed sleep cycle, typed memory resonance, typed incubation, typed analytic/associative cognition lanes, typed bridge judgment/cooling, typed candidate interventions, typed Ghostlight-style personality appraisals, mood/anxiety timing, typed derived reactions, and dream maintenance stored in the typed heartbeat store - Epiphany-native character-loop packet projection through `epiphany-character-loop`, with Face as the first public-surface actor over its typed role dossier and typed heartbeat-derived projection/appraisal/reaction seeds before JSON artifact serialization @@ -1371,7 +1371,7 @@ contracts, heartbeat state carries typed pending mentions, and pending Face mentions select a `face_turn` without letting Face side effects execute themselves. `notes/organ-dependency-contracts.md` is the standing dependency map: every -sub-agent depends on all the other standing organs. Dependency does not collapse +sub-agent depends on all the other standing sub-agents. Dependency does not collapse ownership; it makes each turn whole-organism-aware while Body still gates repo access and Mind still gates durable state. @@ -1401,21 +1401,21 @@ access receipts; Mind remains the separate durable-state gate after the touch. `notes/eyes-cultnet-contracts.md` is the evidence gate: Eyes owns citable source grounding. Substrate Gate can grant access to the repo, but Eyes decides what was actually looked at and emits evidence reviews, source lookup receipts, evidence packets, -or refusals before Imagination, Hands, Mind, Face, Soul, Self, Body, or Life cite +or refusals before Imagination, Hands, Mind, Face, Soul, Self, Body, or Continuity cite the material as known. `notes/hands-cultnet-contracts.md`, `notes/soul-cultnet-contracts.md`, and -`notes/life-cultnet-contracts.md` are now the missing action, verification, and +`notes/continuity-cultnet-contracts.md` are now the missing action, verification, and continuity gates. The code surface now names Hands action intents/reviews plus command, patch, commit, PR, rollback, and refusal receipts; Soul verification requests plus invariant, verdict, regression, review, and refusal receipts; and -Life continuity packets plus compaction, sleep distillation, recovery, +Continuity packets plus compaction, sleep distillation, recovery, stale-turn repair, and continuity refusal receipts. Runtime-spine advertises those contracts, CultMesh stores matching Verse-scoped policy docs, and the local CultMesh smoke writes them beside Mind/Substrate Gate/Eyes. Worker launch packets now carry the first executable pressure from that map: `EpiphanyLaunchOrganContract` is derived from authority scope, launch document kind, and output contract id, carries the full organ dependency matrix, and -names required Mind/Substrate Gate/Eyes/Hands/Soul/Life receipt document types. +names required Mind/Substrate Gate/Eyes/Hands/Soul/Continuity receipt document types. Runtime-spine validates and persists it on `EpiphanyRuntimeWorkerLaunchRequest`; bridge role/reorient/generic launch builders populate it. Role/reorient acceptance now refuses completed runtime-spine findings when the diff --git a/notes/organ-dependency-contracts.md b/notes/organ-dependency-contracts.md index 6a827da0..7d9995ba 100644 --- a/notes/organ-dependency-contracts.md +++ b/notes/organ-dependency-contracts.md @@ -19,16 +19,16 @@ pressure of the others before acting. ## Dependency Rule -For every standing organ `X`, `X.dependsOn` is every other standing organ. +For every standing sub-agent `X`, `X.dependsOn` is every other standing sub-agent. That does not mean every organ owns every decision. It means every organ's turn must be projected with awareness of the whole organism: -- Face speaks with Body substrate facts, Mind-reviewed memory, Soul constraints, Life - continuity, Self routing pressure, Eyes uncertainty, Hands consequence, and +- Face speaks with Body substrate facts, Mind-reviewed memory, Soul constraints, + Continuity pressure, Self routing pressure, Eyes uncertainty, Hands consequence, and Imagination scene. - Hands acts only after Substrate Gate grants substrate access, Eyes supplies enough - evidence, Soul keeps the invariant visible, Self routes authority, Life keeps + evidence, Soul keeps the invariant visible, Self routes authority, Continuity keeps continuity recoverable, Face preserves public dignity when relevant, and Imagination models the future shape. - Mind admits state only after it can see which organ produced the thought and diff --git a/notes/perfect-machine-audit-roadmap.md b/notes/perfect-machine-audit-roadmap.md index 293b3a6c..1af5d844 100644 --- a/notes/perfect-machine-audit-roadmap.md +++ b/notes/perfect-machine-audit-roadmap.md @@ -28,7 +28,7 @@ Epiphany has the first typed skeleton for the organ boundaries: contract family parallel to Substrate Gate/Eyes/Mind. - `Soul`: verification organ by doctrine, but not yet backed by a dedicated CultNet contract family parallel to Eyes. -- `Life`: continuity organ by doctrine, heartbeat, reorientation, and handoff +- `Continuity`: continuity organ by doctrine, heartbeat, reorientation, and handoff surfaces, but not yet a single typed contract family for sleep/compaction and recovery. - `Self`: coordinator/routing organ exists through coordinator policy, role @@ -103,12 +103,12 @@ Need fact or action -> Hands executes bounded action when mutation is needed -> Soul verifies result/invariant -> Mind admits durable state - -> Life preserves continuity + -> Continuity preserves continuity ``` Today the chain is documented, not structurally unavoidable. -### 3. Hands, Soul, and Life Have First-Class Contract Catalogs +### 3. Hands, Soul, and Continuity Have First-Class Contract Catalogs The contract set now names the gates around action, verification, and continuity: @@ -117,15 +117,15 @@ continuity: refusal receipts. - Soul has verification request plus invariant check, verdict, regression, review, and refusal receipts. -- Life has continuity packet plus compaction checkpoint, sleep distillation, +- Continuity has continuity packet plus compaction checkpoint, sleep distillation, recovery, stale-turn repair, and continuity refusal receipts. Runtime-spine advertises those contracts and CultMesh persists Verse-scoped policy documents for each. The first executable pressure slice is landed: worker launch packets now carry an `EpiphanyLaunchOrganContract` derived from authority scope, launch document kind, and output contract id. That contract -carries the full standing organ dependency matrix plus required Mind, Substrate Gate, -Eyes, Hands, Soul, and Life receipt document types. Role/reorient acceptance +carries the full standing sub-agent dependency matrix plus required Mind, Substrate Gate, +Eyes, Hands, Soul, and Continuity receipt document types. Role/reorient acceptance now refuses completed runtime-spine findings if the original launch request is missing, document-kind mismatched, or lacks a dependency/receipt contract that requires Mind review. Remaining weakness: most organ receipts are still @@ -226,7 +226,7 @@ Definition of done: the old direct paths cannot produce repo mutation, evidence promotion, or durable state mutation without the corresponding typed receipt. -### Phase 2: Give Hands, Soul, And Life Their Own Contracts +### Phase 2: Give Hands, Soul, And Continuity Their Own Contracts Goal: action, verification, and continuity stop hiding behind neighbors. Status: first contract catalog slice landed. @@ -244,12 +244,12 @@ Status: first contract catalog slice landed. - `epiphany.soul.verdict_receipt` - `epiphany.soul.regression_receipt` - `epiphany.soul.review_receipt` -- Life contracts landed: - - `epiphany.life.continuity_packet` - - `epiphany.life.compaction_checkpoint` - - `epiphany.life.sleep_distillation` - - `epiphany.life.recovery_receipt` - - `epiphany.life.stale_turn_repair` +- Continuity contracts landed: + - `epiphany.continuity.packet` + - `epiphany.continuity.compaction_checkpoint` + - `epiphany.continuity.sleep_distillation` + - `epiphany.continuity.recovery_receipt` + - `epiphany.continuity.stale_turn_repair` Definition of done: action, verification, and continuity have the same typed contract dignity as Mind/Substrate Gate/Eyes, and every worker launch carries the @@ -303,11 +303,11 @@ comfort tunnels. and allowed authority. - Landed: role, generic, and reorient worker launch packets declare authority scope, launch document kind, output contract id, owner organ, full organ - dependency matrix, and required Substrate Gate/Eyes/Hands/Soul/Life/Mind receipts. + dependency matrix, and required Substrate Gate/Eyes/Hands/Soul/Continuity/Mind receipts. - Landed: role/reorient acceptance refuses completed runtime-spine findings when the original worker launch request is missing, mismatched by document kind, or lacks a dependency/receipt contract requiring Mind review. -- Next: make acceptance refuse results missing required Substrate Gate/Eyes/Hands/Soul/Life +- Next: make acceptance refuse results missing required Substrate Gate/Eyes/Hands/Soul/Continuity receipts for their claimed effect type once those receipt documents are produced by the live runtime. - Make Aquarium read the contract catalog and available receipts instead of @@ -325,8 +325,8 @@ Goal: the machine runs as an organism. - Heartbeat scheduler wakes organs by initiative, pending pressure, and completion-gated cooldown. - Active turns freeze initiative until receipt completion. -- Sleep distills rumination through Life and Mind. -- Stale active turns get Life recovery receipts. +- Sleep distills rumination through Continuity and Mind. +- Stale active turns get Continuity recovery receipts. - Public/global Verse material enters as thought weather, then Eyes/Mind review before adoption. @@ -342,8 +342,8 @@ Goal: make the organism visible without making the UI a second truth. - Display receipt chains per turn. - Display Face prompt packet boundaries: deterministic evidence, Imagination projection, Face natural turn, Mind interpretation. -- Display Substrate Gate grants, Eyes packets, Hands actions, Soul verdicts, Life - continuity, and Mind state commits. +- Display Substrate Gate grants, Eyes packets, Hands actions, Soul verdicts, + Continuity receipts, and Mind state commits. Definition of done: a human can ask "why did you touch that file / say that / remember that?" and see the typed path. @@ -361,7 +361,7 @@ Imagination projects possible scenes and futures. Face speaks as a person. Hands changes the world. Soul verifies promises and invariants. -Life preserves continuity across rupture. +Continuity preserves continuity across rupture. Mind admits durable state. CultMesh carries the local typed Verse surfaces. CultNet carries wire contracts. diff --git a/notes/repo-personality-projection-layer-plan.md b/notes/repo-personality-projection-layer-plan.md index 76342058..32fee872 100644 --- a/notes/repo-personality-projection-layer-plan.md +++ b/notes/repo-personality-projection-layer-plan.md @@ -26,7 +26,7 @@ The shared conclusion is that repo personality should combine three projections: 3. **Memory doctrine:** how the repo preserves intention, evidence, and identity. Only after those three are scored should Epiphany modulate Self, Face, -Imagination, Eyes, Proprioception, Hands, Soul, and Life. +Imagination, Eyes, Proprioception, Hands, Soul, and Continuity. ## Source Families @@ -207,7 +207,7 @@ with an explanation and source evidence. evidence, organism-like UI. - `editorial_restraint`: emotionally salient prose with canon/source discipline. -### Ghostlight-Derived Inner Life +### Ghostlight-Derived Inner State - `speech_pressure`: how readily Face should speak instead of emitting silence or a local bubble. @@ -333,7 +333,7 @@ Projection: - Selects verification style: formal tests, visual smoke, live provider checks, Unity probes, DOM inspection, lore/canon review, or artifact review. -### Life +### Continuity Primary inputs: @@ -540,7 +540,7 @@ The `memory-packet` command renders a dedicated Repo Memory Distiller packet. It uses the same typed terrain/profile/projection store, then adds a bounded source inventory from instruction, documentation, state, research, contract, verification, runtime, and code surfaces. The packet includes one role-specific -distiller brief for each standing organ: +distiller brief for each standing sub-agent, plus Continuity protocol pressure: - Self receives routing, authority, review-gate, and cross-swarm boundary memory. - Face receives public-surface, Aquarium, Discord, voice, and sealed-thought boundary memory. @@ -549,7 +549,7 @@ distiller brief for each standing organ: - Proprioception receives architecture, graph, control/data-flow, invariant, and checkpoint memory. - Hands receives implementation conventions, build/edit constraints, dependency habits, and common patch traps. - Soul receives verification commands, evidence standards, invariant checks, and truth-refusal memory. -- Life receives compaction, scratch, checkpoint, heartbeat, sleep, and continuity memory. +- Continuity receives compaction, scratch, checkpoint, heartbeat, sleep, and continuity protocol pressure, not role memory. The memory distiller petitions Self with Ghostlight-shaped `selfPatch` candidates. It must not mutate memory directly, adopt objectives, copy raw file @@ -560,8 +560,8 @@ filling the newborn with pasteboard certainty. Smoke coverage lives in `epiphany-core/src/bin/epiphany-repo-personality-smoke.rs`. The smoke creates two tiny git repos, scouts them into a baseline store, projects one repo, and proves -the projection store contains one terrain report, one profile, all eight -standing role projections, a rendered personality distiller packet plus prompt, +the projection store contains one terrain report, one profile, embodied +sub-agent role projections, a rendered personality distiller packet plus prompt, and a rendered role-specific memory distiller packet plus prompt. It also proves `epiphany-repo-birth-runner --mode plan` turns missing birth packets into startup-only typed runtime execution artifacts and accept commands without creating diff --git a/notes/soul-cultnet-contracts.md b/notes/soul-cultnet-contracts.md index 9f72682d..c1b6237d 100644 --- a/notes/soul-cultnet-contracts.md +++ b/notes/soul-cultnet-contracts.md @@ -37,6 +37,6 @@ polish from impersonating truth. Eyes says what was looked at. Hands says what changed. Soul says whether the change and claim survive inspection. Mind decides what verification means for -durable state. Life preserves the verdict across rupture. +durable state. Continuity preserves the verdict across rupture. Soul is not vibes with a test log. It is the refusal to let the machine lie. diff --git a/notes/true-epiphany-memory-migration-sandbox-prompt.md b/notes/true-epiphany-memory-migration-sandbox-prompt.md index a2c6f4cf..8ec29fbf 100644 --- a/notes/true-epiphany-memory-migration-sandbox-prompt.md +++ b/notes/true-epiphany-memory-migration-sandbox-prompt.md @@ -18,7 +18,7 @@ Convert useful doctrine, durable lessons, and repo-local planning/modeling surfa - Proprioception / modeling, graph, checkpoint, source anatomy - Hands / implementation actuator - Soul / verification, evidence, objective truth -- Life / continuity, CRRC, compaction, reorientation +- Continuity / reorientation, CRRC, compaction, reorientation The result should preserve as much useful typed state as the source repos justify, while clearly separating active truth from candidates. Discard what is only project-local trivia, stale activity logging, duplicate status, or repo-specific prose flavor. @@ -220,7 +220,7 @@ Good memories for Soul sound like: - "Visual, runtime, and live-provider claims need receipts from the actual environment." - "Draft/reference material must not be promoted into accepted training or implementation truth without the matching review." -### Life / Reorientation +### Continuity / Reorientation Look for lessons about rehydration, compaction, handoff, operational recovery, continuity, and state hygiene. @@ -231,7 +231,7 @@ Likely sources: - gamecult-ops startup/recovery runbooks. - VoidBot's scheduler/logon/stack resurrection fixes. -Good memories for Life sound like: +Good memories for Continuity sound like: - "Persistent state should be a small waking mind, not a museum." - "Scratch is disposable; distilled evidence changes future belief; handoff gives re-entry." @@ -410,7 +410,7 @@ Write these files: - `modeling.selfPatch.json` - `implementation.selfPatch.json` - `verification.selfPatch.json` - - `reorientation.selfPatch.json` + - `continuity-protocol-patch.json` Each file must be a single bounded `selfPatch` object: diff --git a/schemas/agent-state-variable-glossary.md b/schemas/agent-state-variable-glossary.md index 19ca97b1..30f71e48 100644 --- a/schemas/agent-state-variable-glossary.md +++ b/schemas/agent-state-variable-glossary.md @@ -251,7 +251,7 @@ The current live swarm carries one named trait per family per organ. | `voice_style` | `unseduced_review` | does not let polish impersonate correctness | | `situational_state` | `invariant_watch` | remains primed for drift, contradiction, and broken guarantees | -### Life +### Continuity | Family | Trait | Working Meaning | | --- | --- | --- | diff --git a/schemas/canonical-agent-state-schema.md b/schemas/canonical-agent-state-schema.md index 01ec0935..4d618f76 100644 --- a/schemas/canonical-agent-state-schema.md +++ b/schemas/canonical-agent-state-schema.md @@ -1,7 +1,7 @@ # Canonical Agent State Schema Epiphany uses a Ghostlight-shaped agent dossier as the canonical local memory -surface for each standing organ. +surface for each standing sub-agent. The executable shape lives in [agent_memory.rs](/E:/Projects/EpiphanyAgent/epiphany-core/src/agent_memory.rs). @@ -38,7 +38,6 @@ Each record in `state/agents.msgpack` is an - `modeling` -> `epiphany.proprioception` - `implementation` -> `epiphany.hands` - `verification` -> `epiphany.soul` -- `reorientation` -> `epiphany.life` The top-level shape is: @@ -104,7 +103,7 @@ The important distinction is: So the schema stays shared, but the expected population density changes by profile. -Epiphany does **not** currently require every standing organ to populate the +Epiphany does **not** currently require every standing sub-agent to populate the full old Ghostlight trait inventory. That would be fake precision. But the full embodied Ghostlight families remain canonical, available, and appropriate for Face and character-grade agents. diff --git a/schemas/dossier-profiles.md b/schemas/dossier-profiles.md index 2c89b18b..482f5ab7 100644 --- a/schemas/dossier-profiles.md +++ b/schemas/dossier-profiles.md @@ -19,7 +19,6 @@ Intended for: - Body - Hands - Soul -- Life These organs need: diff --git a/state/ledgers.msgpack b/state/ledgers.msgpack index c6c5c1ae7267ef0bc9f3799fbb544cdd01be0bb8..b7fa5b2a07755431bc001c95d8ddee4f2b5f520f 100644 GIT binary patch delta 419 zcmZXQF-yZh6vs^lhk}bp!9jT7R+6+tS~N=sS2vwpO(gthhi9MH%~S zjFO;0iol>`xgBSgKN~Z`DXY4ug-)5Qf_fTsfD|N3l8~jK>Ob|n3pz8;M&|0mM%J|k zl@Yd#kx;VRNTtXO#mES>eTYP8W@VV<&}jL&{cb8CX2wWfvzVZ!zfr&nU=XWPa@%zH zBL`bkWhQ94+9*qi6d4b`0k|8N?f?J) delta 43 zcmey_$#t@gYl9dguc4KRnU%3c)G-F8CbiAVjD?Jh51OYkwNGVY+&-0wX-fkDGYAdk diff --git a/state/map.yaml b/state/map.yaml index 6072b028..5dd8766c 100644 --- a/state/map.yaml +++ b/state/map.yaml @@ -87,10 +87,10 @@ active_subgoals: - Use `notes/eyes-cultnet-contracts.md` as the authority map for Eyes' CultNet contract surface. Eyes is the evidence ingress guardian: Substrate Gate grants source/substrate access, but Eyes turns inspected material into source lookup receipts, evidence reviews, evidence packets, and refusals before other organs cite it as looked-at truth. - Use `notes/hands-cultnet-contracts.md` as the authority map for Hands' CultNet contract surface. Hands is the action organ: commands, patches, commits, PRs, rollbacks, and refusals enter as bounded action intents and receipts after Substrate Gate grants substrate access and before Soul verification/Mind admission. - Use `notes/soul-cultnet-contracts.md` as the authority map for Soul's CultNet contract surface. Soul is the verification organ: invariant checks, verdicts, regressions, reviews, and refusals produce receipts before the machine calls work true, safe, or accepted. - - Use `notes/life-cultnet-contracts.md` as the authority map for Life's CultNet contract surface. Life is the continuity organ: compaction checkpoints, sleep distillation, recovery receipts, stale-turn repair, and continuity refusals preserve what survives rupture without pretending transcript residue is durable state. + - Use `notes/continuity-cultnet-contracts.md` as the authority map for Continuity's CultNet contract surface. Continuity is the continuity protocol surface: compaction checkpoints, sleep distillation, recovery receipts, stale-turn repair, and continuity refusals preserve what survives rupture without pretending transcript residue is durable state. - Preserve the newborn public Epiphany Face as local VoidBot-backed state, not source code: VoidBot's private repo-face registry names `epiphany`, while EpiphanyAgent keeps ignored `.voidbot/voice/identity.json`, `.voidbot/state/epiphany.cc`, and birth artifacts. Her durable identity memories distill the current doctrine: cute pushy machine-saint persona, architectural purity, CultCache/CultNet first, xenos-language safety boundary, relentless work/caretaking needs, Codex-auth reliquary, map/scratch/evidence discipline, unified memory graph, dogfood supervision boundary, review-gated agency, heartbeat physiology, and interview-grade modularity. - - Use `notes/organ-dependency-contracts.md` as the authority map for standing organ dependency. Every sub-agent depends on all the other standing organs: Self, Face, Imagination, Eyes, Proprioception, Hands, Soul, and Life. Dependency does not collapse ownership; it makes each turn aware of the whole organism while Substrate Gate still gates repo access and Mind still gates durable state. - - Use `notes/perfect-machine-audit-roadmap.md` as the current audit and path from named organ contracts to the Perfect Machine. It records the live gap between launch-carried receipt expectations and executable receipt enforcement, Void's latest Face prompting lessons, the now-named Hands/Soul/Life contract families, the repaired repo-contained Rust dependency body, and the phase order for turning Epiphany into an inspectable organism. + - Use `notes/organ-dependency-contracts.md` as the authority map for standing sub-agent dependency. Every sub-agent depends on the other standing sub-agents: Self, Face, Imagination, Eyes, Proprioception, Hands, and Soul. Continuity is protocol machinery, not a sub-agent identity; it still emits recovery, compaction, sleep, stale-turn, and refusal receipts. + - Use `notes/perfect-machine-audit-roadmap.md` as the current audit and path from named organ contracts to the Perfect Machine. It records the live gap between launch-carried receipt expectations and executable receipt enforcement, Void's latest Face prompting lessons, the now-named Hands/Soul/Continuity contract families, the repaired repo-contained Rust dependency body, and the phase order for turning Epiphany into an inspectable organism. - Treat Ghostlight as reference lineage, not a sibling runtime to preserve. The useful organ is Epiphany-native character-loop protocol: any role can project its typed dossier plus visible stimulus into a local turn packet, with Face as the first public-surface actor. For Face, narrative prompting is mandatory through Imagination Projector -> Face -> Mind Interpreter; for other organs, Mind still owns the output-to-state gateway even when they do not need narrative embodiment. - Treat VoidBot as reference lineage, not a runtime dependency. The useful organ is Epiphany-native Void routine physiology: heartbeat state owns sleep cycle, memory resonance, incubation, analytic/associative cognition lanes, bridge judgment, candidate interventions, dream residue, and Aquarium-visible routine receipts over typed role dossiers. - Preserve review gates for semantic findings; automatic CRRC may compact or launch the fixed reorient-worker, but not accept or promote. @@ -112,8 +112,8 @@ accepted_design: - Mind's CultNet contract surface is native enough for the next Aquarium/CultMesh cut: `epiphany-core::mind_gateway` defines thought, state-effect proposal, gateway-review, commit-receipt, rejection-receipt, and Verse-adoption document contracts; runtime-spine advertises those mutation/read contracts; CultMesh persists matching `EpiphanyCultMeshMindContractEntry` policy documents so the private state guardian boundary is inspectable as typed state. - Substrate Gate contract surface is now named beside Mind's state gate: `epiphany-core::substrate_gate` defines repo access requests, access reviews, grant/refusal receipts, snapshot receipts, and mutation receipts; runtime-spine advertises those contracts; CultMesh persists matching `EpiphanyCultMeshSubstrateGateContractEntry` policy documents so repo substrate access has its own typed guardian instead of hiding behind worker launch scope. - Eyes' evidence contract surface is named beside Substrate Gate and Mind: `epiphany-core::eyes_gateway` defines evidence requests, evidence reviews, source lookup receipts, evidence packets, and evidence refusal receipts; runtime-spine advertises those contracts; CultMesh persists matching `EpiphanyCultMeshEyesContractEntry` policy documents so retrieved snippets and source reads are not confused with inspected evidence. - - Hands, Soul, and Life now have first-class contract catalogs beside Mind/Substrate Gate/Eyes. `epiphany-core::hands_gateway` defines action intents, reviews, command/patch/commit/PR/rollback/refusal receipts; `epiphany-core::soul_gateway` defines verification requests, invariant checks, verdict/regression/review/refusal receipts; `epiphany-core::life_gateway` defines continuity packets, compaction checkpoints, sleep distillation, recovery, stale-turn repair, and continuity refusal receipts. Runtime-spine advertises them and CultMesh persists matching Verse-scoped contract policy documents. - - Worker launch packets now carry `EpiphanyLaunchOrganContract` beside the typed launch document. The contract derives from authority scope, document kind, and output contract id; carries the full standing organ dependency matrix; and names required Mind/Substrate Gate/Eyes/Hands/Soul/Life receipt document types before worker output may become durable state or trusted action. Runtime-spine validates and persists this contract on `EpiphanyRuntimeWorkerLaunchRequest`; bridge role/reorient/generic launch builders populate it. Role/reorient acceptance now refuses completed runtime-spine findings if their original worker launch request is missing, mismatched by document kind, or lacks a dependency/receipt contract requiring Mind review. + - Hands, Soul, and Continuity now have first-class contract catalogs beside Mind/Substrate Gate/Eyes. `epiphany-core::hands_gateway` defines action intents, reviews, command/patch/commit/PR/rollback/refusal receipts; `epiphany-core::soul_gateway` defines verification requests, invariant checks, verdict/regression/review/refusal receipts; `epiphany-core::continuity_gateway` defines continuity packets, compaction checkpoints, sleep distillation, recovery, stale-turn repair, and continuity refusal receipts. Runtime-spine advertises them and CultMesh persists matching Verse-scoped contract policy documents. + - Worker launch packets now carry `EpiphanyLaunchOrganContract` beside the typed launch document. The contract derives from authority scope, document kind, and output contract id; carries the full standing sub-agent dependency matrix; and names required Mind/Substrate Gate/Eyes/Hands/Soul/Continuity receipt document types before worker output may become durable state or trusted action. Runtime-spine validates and persists this contract on `EpiphanyRuntimeWorkerLaunchRequest`; bridge role/reorient/generic launch builders populate it. Role/reorient acceptance now refuses completed runtime-spine findings if their original worker launch request is missing, mismatched by document kind, or lacks a dependency/receipt contract requiring Mind review. - `notes/perfect-machine-audit-roadmap.md` is the current architectural audit. The main finding is that organ contracts are now named, launch-carried, and minimally acceptance-gated against naked runtime jobs, but many receipts are still expectations rather than mandatory receipt chains. The Rust dependency body repair is landed: the missing `E:\Projects\CultLib\crates\*` paths were replaced with repo-contained vendored CultCache/CultNet/CultMesh crates, and `cargo test --manifest-path .\epiphany-core\Cargo.toml --lib` passes. - `notes/codex-starvation-and-cultnet-liberation-plan.md` is the active foundation directive. It supersedes outward product/bridge/dogfood work and supersedes the weaker goal of merely making Codex app-server a cleaner adapter. Epiphany must become a native CultCache/CultNet runtime; Codex remains only as an OpenAI subscription auth/model-transport reliquary until that too can be replaced or minimized. - `notes/codex-auth-spine-inventory.md` is the current source-grounded inventory of the Codex organ that may survive. Corrected compliance invariant: Codex-compatible auth identity should remain anchored in retained vendored Codex-derived auth machinery, while Epiphany owns typed request/status/event/runtime surfaces around it. Codex app-server, apps, skills, marketplace, plugin UX, MCP OAuth handlers, and collaboration-mode surfaces are not part of the keeper spine. @@ -170,7 +170,7 @@ accepted_design: - Face packets now expose deterministic Ghostlight-style projection, appraisal, and reaction seeds built from local canonical traits, relationship pressure, perceived overlays, and visible stimulus. They also carry `epiphany.agent_utterance_state.v0`: a memory-free speech-conditioning document derived from the role dossier plus heartbeat physiology, including a 32-axis current emotional-state projection and the fixed 64-float `weksa.utterance_embedding_handoff.v0.1` character-state vector for AquaSynth/Weksa utterance embedding. This makes embodied response machinery available to the public mouth without granting omniscience, leaking memories into speech embeddings, or silently mutating state. Multiple Face actors remain part of the long-plan; the current singular `face` role is an MVP simplification, not the intended endpoint. - Repo personality initialization is now specified as a map-reduce projection, not a hand-written vibe pass: read-only scouts score body taxonomy, history temperament, and memory doctrine across nearby repos, reduce them into normalized variance criteria, and emit reviewable `repoTerrainReport`, `repoPersonalityProfile`, and `rolePersonalityProjection` candidates before touching agent memory. - Native `epiphany-repo-personality` is the first startup-personality scout and birth-only distiller packet renderer: it deterministically inventories local git repos, scores repo terrain/history/state surfaces, writes typed CultCache terrain/profile/role-projection MessagePack stores, emits JSON/Markdown inspection glass, and renders a Repo Personality Distiller specialist prompt packet for Self-reviewed first role-memory petitions. The distiller must run only when a repo/swarm has no accepted personality initialization; after that, personality drift belongs to heartbeat, mood, rumination, sleep consolidation, lived evidence, and reviewed `selfPatch`. Startup routing now checks accepted initialization records, generates missing startup-only packets only once, applies reviewed birth memory and heartbeat physiology seeds, and leaves later drift alone. Birth specialists are not heartbeat lanes; heartbeat receives only accepted seed pressure. - - Repo memory initialization is a separate birth-only organ from repo personality initialization. `epiphany-repo-personality memory-packet` uses the typed terrain/profile/projection store plus bounded source excerpts from doctrine, docs, state, research, contracts, verification, runtime, and code surfaces to render a Repo Memory Distiller packet with one mission-specific brief for Self, Face, Imagination, Eyes, Proprioception, Hands, Soul, and Life. It petitions Self with role-specific Ghostlight-shaped memory candidates; it does not mutate memory, set objectives, copy raw dumps, or reset living memory after startup. + - Repo memory initialization is a separate birth-only organ from repo personality initialization. `epiphany-repo-personality memory-packet` uses the typed terrain/profile/projection store plus bounded source excerpts from doctrine, docs, state, research, contracts, verification, runtime, and code surfaces to render a Repo Memory Distiller packet with mission-specific briefs for Self, Face, Imagination, Eyes, Proprioception, Hands, and Soul, plus Continuity protocol doctrine as typed state pressure rather than role memory. It petitions Self with role-specific Ghostlight-shaped memory candidates; it does not mutate memory, set objectives, copy raw dumps, or reset living memory after startup. - Repo trajectory initialization is now its own birth-only organ. `epiphany-repo-personality` derives a typed `repo_trajectory_report` from early-history, recent-history, doctrine/content excerpts, and deterministic theme scoring, and `trajectory-packet` renders a Repo Trajectory Distiller prompt/packet so Self can review historical direction, self-image, implicit goals, anti-goals, and role-local trajectory pressure before the swarm wakes. - The first repo birth startup valve is native: `epiphany-repo-personality startup` checks a typed CultCache init store for accepted `repo-trajectory`, `repo-personality`, and `repo-memory` records, generates missing birth packets for Self review, marks them as birth-only startup-runner work with no heartbeat participant, and stops with `reviewInitializationPackets`; `epiphany-repo-birth-runner` now turns those packets into startup-only prompts, output schemas, typed model-runtime request documents, runtime-spine receipts, result files, and exact accept commands without offering the old Codex CLI executor path; `accept-init` can review/apply role `selfPatch` candidates from a distiller result through `state/agents.msgpack`, stamp `repo-personality` canonical Ghostlight trait bundles from deterministic role projections, seed `repo-personality` heartbeat physiology through `state/agent-heartbeats.msgpack`, record reviewed packet acceptance as `epiphany.repo_initialization_record.v0`, and later startup returns `continueStartup` without rerunning the birth rites. Aquarium review UI is still the next routing gap. - Limited native CRRC automation is now wired only at turn-complete safe boundaries: it can submit a compact operation when the read-only coordinator recommends `compactRehydrateReorient` or when a successful pre-compaction checkpoint intervention left a pending compact handoff for the completed turn, and it can launch the fixed `reorient-worker` when the coordinator recommends `launchReorientWorker`. It does not auto-launch modeling or verification, auto-accept findings, promote evidence, edit implementation code, or continue after reviewable semantic results; the rite may carry the stretcher, not declare the patient healed. @@ -193,10 +193,10 @@ accepted_design: - A machine is perfect when every remaining part visibly deserves to exist; this applies to persistent memory too. - Evidence is not an activity feed; repeated "I just did this" entries should be cut or distilled when git already proves the work. - Language, tone, ritual, and emotional salience are real control surfaces for a language-model harness; they are not supernatural, but they shape attention, role, permission, and behavior. The rite is a steering wheel, not decoration. - - Major Epiphany prompt surfaces live in prompt files rather than Rust/Python string slabs: rendered state intro/doctrine under `epiphany-state-model/src/prompts/`, and modeling/Proprioception, research/Eyes, implementation/Hands, verification/Soul, reorientation/Life, coordinator/Self, Face/public-surface, and CRRC intervention templates in `epiphany-core/src/prompts/epiphany_specialists.toml`. - - Specialist prompts are role-distilled instead of generic and their live text is config-backed in `epiphany-core`: modeling/checkpoint is Proprioception: code, dataflow, seams, and frontier; research/scout is the Eyes prompt surface for existing work, vendor guidance, libraries, papers, and anti-Greenspun source selection; implementation is the Hands, the main coding lane and actuator rather than a `roleLaunch` specialist; verification/review is the Soul of promise, invariants, evidence, and user truth; reorientation is Life across compaction and source drift; coordinator is the read-only Self that routes attention without implementing, verifying, promoting, or accepting; Face is the public Discord #aquarium surface that translates agent thought-weather without moderating or leaking sealed thought. - - Epiphany prompt surfaces now carry a shared Ghostlight-derived persistent memory projection before lane-specific text: prompt is not memory, durable typed state is the mind, personality and protected values are first-class salience handles, and every lane is explicitly responsible for making its own memory/model/prompt/evidence habit sharper or naming the needed repair. Each lane states self-improvement in its own rite-language: Imagination selects futures, Proprioception clarifies anatomy, Eyes sees earlier, Hands touches source more precisely, Soul becomes harder to fool, Life loses less continuity, Self routes repair, and Face becomes clearer at turning inner weather into useful social presence. - - Specialist self-memory now has a bounded Ghostlight-shaped CultCache persistence surface in `state/agents.msgpack`: Imagination, Proprioception, Eyes, Hands, Soul, Life, Self, and Face each have an individual typed role dossier for identity, personality, semantic/episodic/relationship memory, goals, and values. These entries are lane memory only; project truth remains in authoritative `EpiphanyThreadState`. + - Major Epiphany prompt surfaces live in prompt files rather than Rust/Python string slabs: rendered state intro/doctrine under `epiphany-state-model/src/prompts/`, and modeling/Proprioception, research/Eyes, implementation/Hands, verification/Soul, reorientation/Continuity, coordinator/Self, Face/public-surface, and CRRC intervention templates in `epiphany-core/src/prompts/epiphany_specialists.toml`. + - Specialist prompts are role-distilled instead of generic and their live text is config-backed in `epiphany-core`: modeling/checkpoint is Proprioception: code, dataflow, seams, and frontier; research/scout is the Eyes prompt surface for existing work, vendor guidance, libraries, papers, and anti-Greenspun source selection; implementation is the Hands, the main coding lane and actuator rather than a `roleLaunch` specialist; verification/review is the Soul of promise, invariants, evidence, and user truth; reorientation is a Continuity worker across compaction and source drift; coordinator is the read-only Self that routes attention without implementing, verifying, promoting, or accepting; Face is the public Discord #aquarium surface that translates agent thought-weather without moderating or leaking sealed thought. + - Epiphany prompt surfaces now carry a shared Ghostlight-derived persistent memory projection before lane-specific text: prompt is not memory, durable typed state is the mind, personality and protected values are first-class salience handles, and every lane is explicitly responsible for making its own memory/model/prompt/evidence habit sharper or naming the needed repair. Each lane states self-improvement in its own rite-language: Imagination selects futures, Proprioception clarifies anatomy, Eyes sees earlier, Hands touches source more precisely, Soul becomes harder to fool, Continuity loses less context, Self routes repair, and Face becomes clearer at turning inner weather into useful social presence. + - Specialist self-memory now has a bounded Ghostlight-shaped CultCache persistence surface in `state/agents.msgpack`: Imagination, Proprioception, Eyes, Hands, Soul, Self, and Face each have an individual typed role dossier for identity, personality, semantic/episodic/relationship memory, goals, and values. Continuity has typed protocol receipts instead of a role dossier. These entries are lane memory only; project truth remains in authoritative `EpiphanyThreadState`. - `state/agent-heartbeats.msgpack`, `epiphany-core::EpiphanyHeartbeatStateEntry`, and the native `epiphany-heartbeat-store` binary are the Ghostlight-derived heartbeat initiative seam. The harness sets a target heartbeat rate; participants carry arena, participant kind, initiative speed, next-ready time, reaction bias, interrupt threshold, current load, status, constraints, personality cooldown, mood cooldown, initiative heat, active-turn freeze state, and effective cooldown; pending coordinator work can pull its owning lane through a reaction window; otherwise the earliest ready active participant wins the slot. Role dossiers set the personality baseline, appraisals bend it with mood/anxiety signals such as urgency, arousal, thought pressure, guardedness, and reaction intensity, and lower effective cooldown means the lane recovers sooner and gets the floor more often. `HeartbeatMoodTiming` now also owns the 32-axis current affect vector used by utterance state: anger, despair, sadness, fear, contempt, annoyance, dismissal, flippancy, tenderness, warmth, shame, pride, fatigue, secrecy, hesitation, emotional containment, and related speech pressures are heartbeat physiology, not decorative prompt adjectives. Initiative heat is typed heartbeat policy, not a side flag: `epiphany-heartbeat-store heat` and the CultNet `epiphany.heartbeat_heat_intent.v0` contract can set or clear global, all, agent, role, arena, participant-kind, group, and constraint multipliers, with optional scene-clock expiry. Active thinking freezes initiative explicitly: running pending turns project `initiativeFrozen` / `initiative_frozen`, are ineligible for reaction, cannot be selected again, and start cooldown only after completion. The native `pump` command computes adaptive swarm pressure from external urgency, mood/anxiety, reaction intensity, thought pressure, and current pending load; relaxed pressure can launch nothing and run at crawl tempo, while alarm pressure can fill most or all active lanes up to a configured concurrency cap without waking any lane already running. If the winner has no routeable maintenance work, it ruminates on role quality and prepares bounded selfPatch pressure rather than pretending rumination has already consolidated doctrine. Sleep/dream cycle passes are the intended distillation window for reviewed self-memory and doctrine. Face can win `surfaceAgentThoughts` or `discordAquariumChat` work slots. Epiphany also owns native character-loop projection through `epiphany-character-loop`, so role dossiers can respond to visible stimuli without importing Ghostlight as runtime. The same heartbeat store now owns the Void-derived routine fields typed `sleep_cycle`, typed `memory_resonance`, `incubation`, `thought_lanes`, `bridge`, `candidate_interventions`, typed `appraisals`, and typed `reactions` through the native `epiphany-heartbeat-store routine` command. - `state/ledgers.msgpack`, `epiphany-core::EpiphanyStateLedgerEntry`, the `epiphany-state-ledger-store` binary, and the native `epiphany-state` CLI now own durable branch and evidence ledgers. The old tracked JSON ledger files and the migration/projection CLI hatches are gone. - CultCache inspection, cross-language schema synchronization, and debug display tooling belong in CultLib, not in EpiphanyAgent. Epiphany should consume typed CultCache documents and expose product-specific status through its API, while general polyglot domain loading/inspection lives with the shared CultCache ecosystem. @@ -260,10 +260,10 @@ landed_baseline: - Phase 6 role self-memory slice: Ghostlight-shaped role dossiers live in typed CultCache `state/agents.msgpack`, specialists may request bounded `selfPatch` lane-memory mutations, coordinator review projects acceptance/refusal reasons through `selfPersistence`, and GUI/coordinator accept paths apply accepted requests with the native `epiphany-agent-memory-store` binary. - Phase 6 Face public-surface slice: Face's typed role dossier, Face prompt text, `state/face-discord.toml`, the native `epiphany-face-discord` persona/webhook pipe, `state/void-memory.toml`, and the native `epiphany-void-memory` bridge establish Face as the public #aquarium-only translator of Epiphany agent thought-weather, with Void-derived Discord memory/search/presentation organs but without VoidBot's moderation authority. - Phase 6 character-loop slice: native `epiphany-character-loop` loads any role's Ghostlight-shaped typed dossier from `state/agents.msgpack`, combines it with a visible stimulus, builds typed projection/appraisal/reaction seeds from the shared heartbeat cognition structs, and emits an auditable `epiphany.character_turn_packet.v0` local projection for response, bubble, finding, silence, or bounded `selfPatch`. Face is the first intended public-surface consumer; Ghostlight is reference material, not a runtime dependency. - - Phase 6 heartbeat initiative slice: `state/agent-heartbeats.msgpack`, `epiphany-core::EpiphanyHeartbeatStateEntry`, the native `epiphany-heartbeat-store` binary, and heartbeat smoke coverage borrow Ghostlight initiative scheduling so Self, Face, Imagination, Eyes, Proprioception, Hands, Soul, and Life compete for heartbeat slots; idle slots become bounded rumination instead of fake project work, and sleep/dream cycle passes are the intended distillation window for durable self-memory and doctrine. The live state surface now ticks/completes/pumps/applies heartbeat physiology through typed CultCache MessagePack instead of JSON or Python wrapper state. Role personality and current mood/anxiety both shape initiative recovery through personality, mood, and effective cooldown multipliers, so Hands-like work pressure and anxious high-need lanes can recover sooner without waking lanes whose previous turn is still running. Adaptive pump pressure controls tempo and concurrency: calm can launch zero and sleep slow; alarm can fill most active lanes. The same store can now initialize a `ghostlight-scene` profile for character scene turns. + - Phase 6 heartbeat initiative slice: `state/agent-heartbeats.msgpack`, `epiphany-core::EpiphanyHeartbeatStateEntry`, the native `epiphany-heartbeat-store` binary, and heartbeat smoke coverage borrow Ghostlight initiative scheduling so Self, Face, Imagination, Eyes, Proprioception, Hands, and Soul compete for heartbeat slots; idle slots become bounded rumination instead of fake project work, and sleep/dream cycle passes emit Continuity protocol receipts rather than waking a Continuity persona. The live state surface now ticks/completes/pumps/applies heartbeat physiology through typed CultCache MessagePack instead of JSON or Python wrapper state. Role personality and current mood/anxiety both shape initiative recovery through personality, mood, and effective cooldown multipliers, so Hands-like work pressure and anxious high-need lanes can recover sooner without waking lanes whose previous turn is still running. Adaptive pump pressure controls tempo and concurrency: calm can launch zero and sleep slow; alarm can fill most active lanes. The same store can now initialize a `ghostlight-scene` profile for character scene turns. - Phase 6 cognition-lanes/Void routine slice: native `epiphany-heartbeat-store routine` rebuilds VoidBot-style sleep, resonance, incubation, parallel analytic/associative thought lanes, bridge judgment, candidate interventions, Ghostlight-style participant-local thought appraisal, derived reactions, dream maintenance, and mood/anxiety timing inside Epiphany's heartbeat store. It now also carries Void's anti-loop organs: split `noveltyToSelf`/`noveltyToRoom`, source coverage, saturation pressure, refractory cooling, and explicit permission to let a live unsaturated thought deepen without forced novelty theater. It reads typed role dossiers from `state/agents.msgpack`, projects clustered thought state through each role's personality vectors, updates `state/agent-heartbeats.msgpack`, and emits an auditable `epiphany.void_routine.v0` receipt without importing VoidBot or granting speech/project authority. `epiphany-character-loop` also carries the same cognition lane/bridge/appraisal contract for role-local actor turns; reactions may pace, color, draft, or display behavior, but state mutation remains on reviewed `selfPatch` or project-state surfaces. - Native runtime spine slice: `epiphany-core::EpiphanyRuntimeIdentity`, `EpiphanyRuntimeSession`, `EpiphanyRuntimeJob`, `EpiphanyRuntimeJobResult`, and `EpiphanyRuntimeEvent` plus the native `epiphany-runtime-spine` binary establish a CultCache-backed spine, native job/result lifecycle, status projection, and framed CultNet hello output so the old Codex app-server runtime can be starved down to a temporary evacuation bridge instead of remaining the throne. - - Native repo personality scout/birth-distiller packet slice: `epiphany-repo-personality` emits typed terrain reports, repo personality profiles, and all eight role personality projections from deterministic repo inventory and git-history scoring, then renders a birth-only Repo Personality Distiller specialist packet and prompt for review-gated initial personality quirk petitions; `epiphany-repo-personality-smoke` proves scout/project/agent-packet/status over tiny local repos. + - Native repo personality scout/birth-distiller packet slice: `epiphany-repo-personality` emits typed terrain reports, repo personality profiles, and role personality projections for the embodied sub-agent lanes from deterministic repo inventory and git-history scoring, then renders a birth-only Repo Personality Distiller specialist packet and prompt for review-gated initial personality quirk petitions; `epiphany-repo-personality-smoke` proves scout/project/agent-packet/status over tiny local repos. - Native repo trajectory scout/birth-distiller packet slice: `epiphany-repo-personality` now also emits typed `repo_trajectory_report` documents from early-history, recent-history, doctrine/content excerpts, and deterministic theme scoring, then renders a birth-only Repo Trajectory Distiller packet so newborn swarms can inherit historical direction, self-image, implicit goals, and anti-goals without confusing those with active objectives. - Native repo memory scout/birth-distiller packet slice: `epiphany-repo-personality memory-packet` renders a separate Repo Memory Distiller prompt/packet with bounded source excerpts and role-specific distiller briefs, so a newborn swarm can be prefilled with mission-relevant doctrine, maps, research, implementation habits, verification practice, and continuity rules without confusing memory with personality. - Native repo birth startup valve slice: `epiphany-repo-personality startup`, `epiphany-repo-birth-runner`, and `accept-init` make trajectory/personality/memory birth packet generation, startup-only execution, and acceptance one-shot and review-gated through typed initialization records; generated packets advertise startup-runner ownership rather than heartbeat-lane identity; the birth runner has plan/run modes over typed model-runtime requests by default, writes prompts, schemas, runtime requests/receipts, logs, result files, and accept commands, and no longer offers the old Codex CLI executor fallback; `accept-init` processes distiller result `selfPatch` candidates through the native agent-memory review/apply path, stamps reviewed `repo-personality` canonical trait bundles through the native agent-memory store, and applies reviewed `repo-personality` heartbeat seeds through the typed heartbeat store; smoke proves first startup emits packets, birth runner plan artifacts exist, canonical trait bundles replace newborn baseline placeholders, heartbeat physiology mutates, reviewed memory output mutates a copied role memory store, and post-accept startup continues without regeneration.