diff --git a/epiphany-core/src/agent_launch.rs b/epiphany-core/src/agent_launch.rs index 01e69414..ccdda126 100644 --- a/epiphany-core/src/agent_launch.rs +++ b/epiphany-core/src/agent_launch.rs @@ -128,7 +128,7 @@ pub fn epiphany_role_launch_output_schema(role_id: EpiphanyRoleResultRoleId) -> "properties": { "agentId": { "type": "string", - "description": "Expected target persistent agent id for this lane, such as epiphany.body or epiphany.soul." + "description": "Expected target persistent agent id for this lane, such as epiphany.proprioception or epiphany.soul." }, "reason": { "type": "string", diff --git a/epiphany-core/src/agent_memory.rs b/epiphany-core/src/agent_memory.rs index 72d2ce66..c22cc6b1 100644 --- a/epiphany-core/src/agent_memory.rs +++ b/epiphany-core/src/agent_memory.rs @@ -20,7 +20,11 @@ const ROLE_TARGETS: &[(&str, &str, &str)] = &[ "epiphany.imagination", "imagination.agent-state.json", ), - ("modeling", "epiphany.body", "body.agent-state.json"), + ( + "modeling", + "epiphany.proprioception", + "proprioception.agent-state.json", + ), ("verification", "epiphany.soul", "soul.agent-state.json"), ("implementation", "epiphany.hands", "hands.agent-state.json"), ("reorientation", "epiphany.life", "life.agent-state.json"), @@ -1432,8 +1436,8 @@ mod tests { let agent_dir = temp.path().join("agents"); fs::create_dir_all(&agent_dir)?; fs::write( - agent_dir.join("body.agent-state.json"), - sample_agent_json("epiphany.body", "Body"), + agent_dir.join("proprioception.agent-state.json"), + sample_agent_json("epiphany.proprioception", "Proprioception"), )?; for (role_id, agent_id, filename) in ROLE_TARGETS { if *role_id == "modeling" { @@ -1449,8 +1453,8 @@ mod tests { assert!(validate_agent_memory_store(&store)?.is_empty()); let patch: AgentSelfPatch = serde_json::from_value(serde_json::json!({ - "agentId": "epiphany.body", - "reason": "The Body should remember accepted graph growth must stay source-grounded.", + "agentId": "epiphany.proprioception", + "reason": "Proprioception should remember accepted graph growth must stay source-grounded.", "semanticMemories": [{ "memoryId": "mem-body-native-source-grounding", "summary": "Native role memory patches update typed CultCache state rather than JSON dossier files.", @@ -1466,9 +1470,10 @@ mod tests { let mut cache = agent_memory_cache(&store)?; cache.pull_all_backing_stores()?; - let body = cache.get_required::("modeling")?; + let proprioception = cache.get_required::("modeling")?; assert!( - body.agent + proprioception + .agent .memories .semantic .iter() diff --git a/epiphany-core/src/bin/epiphany-agent-memory-store.rs b/epiphany-core/src/bin/epiphany-agent-memory-store.rs index 58b75268..8640cf74 100644 --- a/epiphany-core/src/bin/epiphany-agent-memory-store.rs +++ b/epiphany-core/src/bin/epiphany-agent-memory-store.rs @@ -144,8 +144,8 @@ fn run_smoke(store: &Path) -> Result { })); } let accepted_patch: AgentSelfPatch = serde_json::from_value(serde_json::json!({ - "agentId": "epiphany.body", - "reason": "The Body should remember accepted graph growth must be source-grounded and bounded.", + "agentId": "epiphany.proprioception", + "reason": "Proprioception should remember accepted graph growth must be source-grounded and bounded.", "semanticMemories": [{ "memoryId": "mem-body-smoke-source-grounding", "summary": "A modeling self-memory request is acceptable when it improves future graph/checkpoint judgment without smuggling project truth.", @@ -156,7 +156,7 @@ fn run_smoke(store: &Path) -> Result { let accepted = review_agent_self_patch_document("modeling", &accepted_patch, store); let wrong_role = review_agent_self_patch_document("verification", &accepted_patch, store); let forbidden_patch: AgentSelfPatch = serde_json::from_value(serde_json::json!({ - "agentId": "epiphany.body", + "agentId": "epiphany.proprioception", "reason": "This tries to put project state in lane memory, which should be refused.", "graphs": {}, "semanticMemories": [{ diff --git a/epiphany-core/src/bin/epiphany-cultmesh-smoke.rs b/epiphany-core/src/bin/epiphany-cultmesh-smoke.rs index cfbe03b5..0819ed76 100644 --- a/epiphany-core/src/bin/epiphany-cultmesh-smoke.rs +++ b/epiphany-core/src/bin/epiphany-cultmesh-smoke.rs @@ -8,7 +8,6 @@ use epiphany_core::epiphany_cultmesh_operator_snapshot_from_status_json; use epiphany_core::load_epiphany_cultmesh_operator_status; use epiphany_core::load_epiphany_cultmesh_status; use epiphany_core::load_latest_epiphany_cultmesh_operator_snapshot; -use epiphany_core::write_epiphany_cultmesh_body_contracts; 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; @@ -18,6 +17,7 @@ use epiphany_core::write_epiphany_cultmesh_operator_snapshot; use epiphany_core::write_epiphany_cultmesh_operator_status; use epiphany_core::write_epiphany_cultmesh_soul_contracts; use epiphany_core::write_epiphany_cultmesh_status; +use epiphany_core::write_epiphany_cultmesh_substrate_gate_contracts; use epiphany_core::write_epiphany_cultmesh_verse_policies; use std::path::PathBuf; @@ -40,7 +40,7 @@ fn main() -> Result<()> { write_epiphany_cultmesh_verse_policies(&store, "epiphany-cultmesh-smoke")?; write_epiphany_cultmesh_global_room_policies(&store, "epiphany-cultmesh-smoke")?; write_epiphany_cultmesh_mind_contracts(&store, "epiphany-cultmesh-smoke")?; - write_epiphany_cultmesh_body_contracts(&store, "epiphany-cultmesh-smoke")?; + write_epiphany_cultmesh_substrate_gate_contracts(&store, "epiphany-cultmesh-smoke")?; 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")?; diff --git a/epiphany-core/src/bin/epiphany-face-discord.rs b/epiphany-core/src/bin/epiphany-face-discord.rs index c07156b0..66220fe4 100644 --- a/epiphany-core/src/bin/epiphany-face-discord.rs +++ b/epiphany-core/src/bin/epiphany-face-discord.rs @@ -458,7 +458,7 @@ fn run_smoke() -> Result { env::remove_var("EPIPHANY_FACE_AQUARIUM_CHANNEL_ID_TEST"); } let draft = run_draft( - "Face notices Body and Soul disagree about evidence shape.", + "Face notices Proprioception and Soul disagree about evidence shape.", &config, &temp_dir, "draft", diff --git a/epiphany-core/src/bin/epiphany-repo-personality-smoke.rs b/epiphany-core/src/bin/epiphany-repo-personality-smoke.rs index 02e093ee..5b786ba8 100644 --- a/epiphany-core/src/bin/epiphany-repo-personality-smoke.rs +++ b/epiphany-core/src/bin/epiphany-repo-personality-smoke.rs @@ -439,11 +439,11 @@ fn run_smoke() -> Result { "confidence": 0.9, "roleMemoryPatches": [{ "roleId": "modeling", - "roleName": "Body", + "roleName": "Proprioception", "verdict": "ready-for-review", "selfPatch": { - "agentId": "epiphany.body", - "reason": "Birth memory should teach Body that repo initialization memory is reviewed and typed.", + "agentId": "epiphany.proprioception", + "reason": "Birth memory should teach Proprioception that repo initialization memory is reviewed and typed.", "semanticMemories": [{ "memoryId": "mem-body-startup-birth-memory-smoke", "summary": "Repo memory birth packets can produce role-specific selfPatch candidates that are applied only after Self review.", @@ -452,7 +452,7 @@ fn run_smoke() -> Result { }] }, "sourceRefs": ["AGENTS.md"], - "whyThisBelongsInMemory": "Body needs the startup memory route to stay source-grounded.", + "whyThisBelongsInMemory": "Proprioception needs the startup memory route to stay source-grounded.", "stalenessRisk": "smoke fixture", "doNotStore": [] }] diff --git a/epiphany-core/src/bin/epiphany-repo-personality.rs b/epiphany-core/src/bin/epiphany-repo-personality.rs index e383d01c..36077e4c 100644 --- a/epiphany-core/src/bin/epiphany-repo-personality.rs +++ b/epiphany-core/src/bin/epiphany-repo-personality.rs @@ -1009,7 +1009,7 @@ fn run_trajectory_packet(args: AgentPacketArgs) -> Result { "lifecycle": { "mode": "birth-only", "contract": "Run this specialist only when the repo/swarm has no accepted trajectory initialization. Later direction drift belongs to heartbeat, mood, lived work, reviewed selfPatch, and planning/evidence truth.", - "rerunPolicy": "If accepted trajectory initialization exists, do not rerun to rebrand the repo. Route contradictions through normal Eyes/Body/Imagination/Soul work and reviewed memory drift." + "rerunPolicy": "If accepted trajectory initialization exists, do not rerun to rebrand the repo. Route contradictions through normal Eyes/Proprioception/Imagination/Soul work and reviewed memory drift." }, "prompt": REPO_TRAJECTORY_DISTILLER_PROMPT, "input": { @@ -1118,7 +1118,7 @@ fn run_agent_packet(args: AgentPacketArgs) -> Result { "lifecycle": { "mode": "birth-only", "contract": "Run this specialist only when the repo/swarm has no accepted personality initialization. Later personality movement belongs to heartbeat, mood, rumination, sleep consolidation, lived evidence, and reviewed selfPatch.", - "rerunPolicy": "If an accepted initialization exists, do not rerun to refresh personality. Route major terrain surprises to Eyes/Body or Self review as normal state/model work, not personality reset." + "rerunPolicy": "If an accepted initialization exists, do not rerun to refresh personality. Route major terrain surprises to Eyes/Proprioception or Self review as normal state/model work, not personality reset." }, "prompt": REPO_PERSONALITY_DISTILLER_PROMPT, "input": { @@ -1223,7 +1223,7 @@ fn run_memory_packet(args: AgentPacketArgs) -> Result { "lifecycle": { "mode": "birth-only", "contract": "Run this specialist only when the repo/swarm has no accepted memory initialization. Later memory growth belongs to heartbeat, work evidence, rumination, sleep consolidation, and reviewed selfPatch.", - "rerunPolicy": "If accepted memory initialization exists, do not rerun to refresh memory. Route stale or contradicted knowledge through normal Eyes/Body/Soul state, evidence, and sleep consolidation." + "rerunPolicy": "If accepted memory initialization exists, do not rerun to refresh memory. Route stale or contradicted knowledge through normal Eyes/Proprioception/Soul state, evidence, and sleep consolidation." }, "prompt": REPO_MEMORY_DISTILLER_PROMPT, "input": { @@ -2231,7 +2231,7 @@ fn role_id_for_agent_id(agent_id: &str) -> Option<&'static str> { "epiphany.face" => Some("face"), "epiphany.imagination" => Some("imagination"), "epiphany.eyes" => Some("research"), - "epiphany.body" => Some("modeling"), + "epiphany.proprioception" => Some("modeling"), "epiphany.hands" => Some("implementation"), "epiphany.soul" => Some("verification"), "epiphany.life" => Some("reorientation"), @@ -2434,7 +2434,7 @@ fn memory_role_filter(role_id: &str) -> &'static str { "Distill known prior art, standard algorithms, vendor docs, research trails, and signals that should make Eyes search before invention." } "modeling" => { - "Distill architecture, control/data-flow, graph frontiers, invariants, source-map practices, and what Body must understand before Hands cuts." + "Distill architecture, control/data-flow, graph frontiers, invariants, source-map practices, and what Proprioception must understand before Hands cuts." } "implementation" => { "Distill build/edit conventions, harness constraints, source-touch rules, coding style, dependency policy, and common traps for Hands." @@ -3949,7 +3949,7 @@ fn role_display(role_id: &str) -> &'static str { "face" => "Face", "imagination" => "Imagination", "research" => "Eyes", - "modeling" => "Body", + "modeling" => "Proprioception", "implementation" => "Hands", "verification" => "Soul", "reorientation" => "Life", diff --git a/epiphany-core/src/body_gateway.rs b/epiphany-core/src/body_gateway.rs deleted file mode 100644 index 9a45c530..00000000 --- a/epiphany-core/src/body_gateway.rs +++ /dev/null @@ -1,127 +0,0 @@ -use serde::Deserialize; -use serde::Serialize; - -pub const BODY_REPO_ACCESS_REQUEST_TYPE: &str = "epiphany.body.repo_access_request"; -pub const BODY_REPO_ACCESS_REVIEW_TYPE: &str = "epiphany.body.repo_access_review"; -pub const BODY_REPO_ACCESS_GRANT_RECEIPT_TYPE: &str = "epiphany.body.repo_access_grant_receipt"; -pub const BODY_REPO_ACCESS_REFUSAL_RECEIPT_TYPE: &str = "epiphany.body.repo_access_refusal_receipt"; -pub const BODY_REPO_SNAPSHOT_RECEIPT_TYPE: &str = "epiphany.body.repo_snapshot_receipt"; -pub const BODY_REPO_MUTATION_RECEIPT_TYPE: &str = "epiphany.body.repo_mutation_receipt"; -pub const BODY_REPO_ACCESS_REQUEST_SCHEMA_VERSION: &str = "epiphany.body.repo_access_request.v0"; -pub const BODY_REPO_ACCESS_REVIEW_SCHEMA_VERSION: &str = "epiphany.body.repo_access_review.v0"; -pub const BODY_REPO_ACCESS_GRANT_RECEIPT_SCHEMA_VERSION: &str = - "epiphany.body.repo_access_grant_receipt.v0"; -pub const BODY_REPO_ACCESS_REFUSAL_RECEIPT_SCHEMA_VERSION: &str = - "epiphany.body.repo_access_refusal_receipt.v0"; -pub const BODY_REPO_SNAPSHOT_RECEIPT_SCHEMA_VERSION: &str = - "epiphany.body.repo_snapshot_receipt.v0"; -pub const BODY_REPO_MUTATION_RECEIPT_SCHEMA_VERSION: &str = - "epiphany.body.repo_mutation_receipt.v0"; - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct BodyCultNetContract { - 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_body_cultnet_contracts() -> Vec { - vec![ - BodyCultNetContract { - contract_id: "epiphany.body.repo_access.review".to_string(), - verse_id: "epiphany-internal".to_string(), - document_type: BODY_REPO_ACCESS_REQUEST_TYPE.to_string(), - payload_schema_version: BODY_REPO_ACCESS_REQUEST_SCHEMA_VERSION.to_string(), - authority: "body".to_string(), - operations: vec![ - "intentSubmit".to_string(), - "receiptWatch".to_string(), - "snapshot".to_string(), - ], - intent_document_types: vec![BODY_REPO_ACCESS_REQUEST_TYPE.to_string()], - receipt_document_types: vec![ - BODY_REPO_ACCESS_REVIEW_TYPE.to_string(), - BODY_REPO_ACCESS_GRANT_RECEIPT_TYPE.to_string(), - BODY_REPO_ACCESS_REFUSAL_RECEIPT_TYPE.to_string(), - ], - notes: vec![ - "Body is the repo access guardian: workers request repository reads, indexing, commands, edits, and bridge operations here.".to_string(), - "Hands may mutate files only after Body grants scoped access; Eyes may inspect only through scoped Body read/index grants.".to_string(), - ], - }, - BodyCultNetContract { - contract_id: "epiphany.body.repo_access.review_receipts".to_string(), - verse_id: "epiphany-internal".to_string(), - document_type: BODY_REPO_ACCESS_REVIEW_TYPE.to_string(), - payload_schema_version: BODY_REPO_ACCESS_REVIEW_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![ - "Body reviews explain which repo paths, operations, commands, and bridge surfaces were granted or refused.".to_string(), - ], - }, - BodyCultNetContract { - contract_id: "epiphany.body.repo_snapshot.receipts".to_string(), - verse_id: "epiphany-internal".to_string(), - document_type: BODY_REPO_SNAPSHOT_RECEIPT_TYPE.to_string(), - payload_schema_version: BODY_REPO_SNAPSHOT_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![ - "Repo snapshots are evidence projections from Body access; they do not grant future access by existing.".to_string(), - ], - }, - BodyCultNetContract { - contract_id: "epiphany.body.repo_mutation.receipts".to_string(), - verse_id: "epiphany-internal".to_string(), - document_type: BODY_REPO_MUTATION_RECEIPT_TYPE.to_string(), - payload_schema_version: BODY_REPO_MUTATION_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![ - "Repo mutation receipts prove Body granted the scoped substrate touch before Hands changed files or ran repo-affecting commands.".to_string(), - ], - }, - ] -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn body_contracts_make_internal_verse_the_repo_access_gate() { - let contracts = default_body_cultnet_contracts(); - let repo_access = contracts - .iter() - .find(|contract| contract.contract_id == "epiphany.body.repo_access.review") - .expect("repo access review contract"); - - assert_eq!(repo_access.verse_id, "epiphany-internal"); - assert_eq!(repo_access.authority, "body"); - assert!( - repo_access - .notes - .iter() - .any(|note| note.contains("repo access guardian")) - ); - assert!( - repo_access - .receipt_document_types - .contains(&BODY_REPO_ACCESS_GRANT_RECEIPT_TYPE.to_string()) - ); - } -} diff --git a/epiphany-core/src/cultmesh_integration.rs b/epiphany-core/src/cultmesh_integration.rs index d5a4ac1c..2fdd754e 100644 --- a/epiphany-core/src/cultmesh_integration.rs +++ b/epiphany-core/src/cultmesh_integration.rs @@ -1,9 +1,9 @@ -use crate::default_body_cultnet_contracts; use crate::default_eyes_cultnet_contracts; use crate::default_hands_cultnet_contracts; use crate::default_life_cultnet_contracts; use crate::default_mind_cultnet_contracts; use crate::default_soul_cultnet_contracts; +use crate::default_substrate_gate_cultnet_contracts; use anyhow::Result; use anyhow::anyhow; use cultcache_rs::DatabaseEntry; @@ -46,9 +46,10 @@ pub const EPIPHANY_CULTMESH_GLOBAL_ROOM_POLICY_SCHEMA_VERSION: &str = pub const EPIPHANY_CULTMESH_MIND_CONTRACT_TYPE: &str = "epiphany.cultmesh.mind_contract"; pub const EPIPHANY_CULTMESH_MIND_CONTRACT_SCHEMA_VERSION: &str = "epiphany.cultmesh.mind_contract.v0"; -pub const EPIPHANY_CULTMESH_BODY_CONTRACT_TYPE: &str = "epiphany.cultmesh.body_contract"; -pub const EPIPHANY_CULTMESH_BODY_CONTRACT_SCHEMA_VERSION: &str = - "epiphany.cultmesh.body_contract.v0"; +pub const EPIPHANY_CULTMESH_SUBSTRATE_GATE_CONTRACT_TYPE: &str = + "epiphany.cultmesh.substrate_gate_contract"; +pub const EPIPHANY_CULTMESH_SUBSTRATE_GATE_CONTRACT_SCHEMA_VERSION: &str = + "epiphany.cultmesh.substrate_gate_contract.v0"; pub const EPIPHANY_CULTMESH_EYES_CONTRACT_TYPE: &str = "epiphany.cultmesh.eyes_contract"; pub const EPIPHANY_CULTMESH_EYES_CONTRACT_SCHEMA_VERSION: &str = "epiphany.cultmesh.eyes_contract.v0"; @@ -324,10 +325,10 @@ pub struct EpiphanyCultMeshMindContractEntry { #[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)] #[cultcache( - type = "epiphany.cultmesh.body_contract", - schema = "EpiphanyCultMeshBodyContractEntry" + type = "epiphany.cultmesh.substrate_gate_contract", + schema = "EpiphanyCultMeshSubstrateGateContractEntry" )] -pub struct EpiphanyCultMeshBodyContractEntry { +pub struct EpiphanyCultMeshSubstrateGateContractEntry { #[cultcache(key = 0)] pub schema_version: String, #[cultcache(key = 1)] @@ -471,7 +472,7 @@ cultmesh_documents!(EpiphanyCultMeshDocuments { EpiphanyCultMeshVersePolicyEntry => EPIPHANY_CULTMESH_VERSE_POLICY_SCHEMA_VERSION, EpiphanyCultMeshGlobalRoomPolicyEntry => EPIPHANY_CULTMESH_GLOBAL_ROOM_POLICY_SCHEMA_VERSION, EpiphanyCultMeshMindContractEntry => EPIPHANY_CULTMESH_MIND_CONTRACT_SCHEMA_VERSION, - EpiphanyCultMeshBodyContractEntry => EPIPHANY_CULTMESH_BODY_CONTRACT_SCHEMA_VERSION, + EpiphanyCultMeshSubstrateGateContractEntry => EPIPHANY_CULTMESH_SUBSTRATE_GATE_CONTRACT_SCHEMA_VERSION, EpiphanyCultMeshEyesContractEntry => EPIPHANY_CULTMESH_EYES_CONTRACT_SCHEMA_VERSION, EpiphanyCultMeshHandsContractEntry => EPIPHANY_CULTMESH_HANDS_CONTRACT_SCHEMA_VERSION, EpiphanyCultMeshSoulContractEntry => EPIPHANY_CULTMESH_SOUL_CONTRACT_SCHEMA_VERSION, @@ -864,11 +865,12 @@ pub fn write_epiphany_cultmesh_mind_contracts( Ok(written) } -pub fn epiphany_cultmesh_body_contracts() -> Vec { - default_body_cultnet_contracts() +pub fn epiphany_cultmesh_substrate_gate_contracts() +-> Vec { + default_substrate_gate_cultnet_contracts() .into_iter() - .map(|contract| EpiphanyCultMeshBodyContractEntry { - schema_version: EPIPHANY_CULTMESH_BODY_CONTRACT_SCHEMA_VERSION.to_string(), + .map(|contract| EpiphanyCultMeshSubstrateGateContractEntry { + schema_version: EPIPHANY_CULTMESH_SUBSTRATE_GATE_CONTRACT_SCHEMA_VERSION.to_string(), contract_id: contract.contract_id, verse_id: contract.verse_id, document_type: contract.document_type, @@ -882,13 +884,13 @@ pub fn epiphany_cultmesh_body_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_body_contracts() { + for contract in epiphany_cultmesh_substrate_gate_contracts() { written.push(node.put(contract.contract_id.clone(), &contract)?); } node.flush()?; @@ -1279,24 +1281,24 @@ mod tests { } #[test] - fn body_contracts_use_verses_to_keep_repo_access_guarded() -> Result<()> { + fn substrate_gate_contracts_use_verses_to_keep_repo_access_guarded() -> Result<()> { let temp = tempfile::tempdir()?; - let store = temp.path().join("epiphany-body-contracts.ccmp"); - let written = write_epiphany_cultmesh_body_contracts(&store, "epiphany-test")?; + let store = temp.path().join("epiphany-substrate-gate-contracts.ccmp"); + let written = write_epiphany_cultmesh_substrate_gate_contracts(&store, "epiphany-test")?; assert!(written.len() >= 4); let node = open_epiphany_cultmesh_node(&store, "epiphany-test")?; - let repo_access = node.get_required::( - "epiphany.body.repo_access.review", + let repo_access = node.get_required::( + "epiphany.substrate_gate.repo_access.review", )?; assert_eq!(repo_access.verse_id, EPIPHANY_CULTMESH_INTERNAL_VERSE_ID); - assert_eq!(repo_access.authority, "body"); + assert_eq!(repo_access.authority, "substrateGate"); assert!( repo_access .notes .iter() - .any(|note| note.contains("repo access guardian")) + .any(|note| note.contains("repo access protocol")) ); Ok(()) } diff --git a/epiphany-core/src/eyes_gateway.rs b/epiphany-core/src/eyes_gateway.rs index ad117df3..8d83379c 100644 --- a/epiphany-core/src/eyes_gateway.rs +++ b/epiphany-core/src/eyes_gateway.rs @@ -50,7 +50,7 @@ pub fn default_eyes_cultnet_contracts() -> Vec { ], notes: vec![ "Eyes is the evidence ingress guardian: organs request source-grounded lookup, provenance, uncertainty, and evidence packets here.".to_string(), - "Body grants substrate access; Eyes turns inspected material into citable evidence packets.".to_string(), + "Substrate Gate grants substrate access; Eyes turns inspected material into citable evidence packets.".to_string(), ], }, EyesCultNetContract { @@ -76,7 +76,7 @@ pub fn default_eyes_cultnet_contracts() -> Vec { intent_document_types: Vec::new(), receipt_document_types: Vec::new(), notes: vec![ - "Source lookup receipts prove what was searched or inspected, under which Body grant, before another organ cites it.".to_string(), + "Source lookup receipts prove what was searched or inspected, under which Substrate Gate grant, before another organ cites it.".to_string(), ], }, EyesCultNetContract { diff --git a/epiphany-core/src/face_turn.rs b/epiphany-core/src/face_turn.rs index 9876357b..751cf65f 100644 --- a/epiphany-core/src/face_turn.rs +++ b/epiphany-core/src/face_turn.rs @@ -117,10 +117,10 @@ You are not the Face. You are not Mind. You are the membrane that turns typed ro Hard boundary: - Do not choose public speech. - Do not decide durable state; Mind is the Interpreter and state guardian after Face thinks. -- Do not decide repo access; Body gates substrate access before repo facts enter this packet. +- 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, Body, Hands, Soul, and Life without pretending Face owns them. +- 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. - If the state is sparse, say what is sparse without inventing history. Face identity: @@ -432,7 +432,7 @@ mod tests { assert!(projector.contains("You are Imagination acting as the Face Projector")); assert!(projector.contains("You are not the Face")); assert!(projector.contains("Mind is the Interpreter")); - assert!(projector.contains("Body gates substrate access")); + assert!(projector.contains("Substrate Gate grants substrate access")); assert!(projector.contains("Every sub-agent depends on all the other organs")); assert!(projector.contains("Do not choose public speech")); diff --git a/epiphany-core/src/hands_gateway.rs b/epiphany-core/src/hands_gateway.rs index 3a4977fe..ff955f66 100644 --- a/epiphany-core/src/hands_gateway.rs +++ b/epiphany-core/src/hands_gateway.rs @@ -58,7 +58,7 @@ pub fn default_hands_cultnet_contracts() -> Vec { ], notes: vec![ "Hands is the action organ: commands, patches, commits, PRs, and rollbacks enter here as bounded action intents.".to_string(), - "Hands does not grant repo access; Body grants substrate access before Hands mutates, and Soul verifies the result after.".to_string(), + "Hands does not grant repo access; Substrate Gate grants substrate access before Hands mutates, and Soul verifies the result after.".to_string(), ], }, HandsCultNetContract { @@ -71,7 +71,7 @@ pub fn default_hands_cultnet_contracts() -> Vec { intent_document_types: Vec::new(), receipt_document_types: Vec::new(), notes: vec![ - "Hands reviews explain what action was allowed, refused, sequenced, or delegated after Body access was checked.".to_string(), + "Hands reviews explain what action was allowed, refused, sequenced, or delegated after Substrate Gate access was checked.".to_string(), ], }, HandsCultNetContract { @@ -84,7 +84,7 @@ pub fn default_hands_cultnet_contracts() -> Vec { intent_document_types: Vec::new(), receipt_document_types: Vec::new(), notes: vec![ - "Command receipts prove what command ran, under which Body grant, and where output artifacts live.".to_string(), + "Command receipts prove what command ran, under which Substrate Gate grant, and where output artifacts live.".to_string(), ], }, HandsCultNetContract { @@ -97,7 +97,7 @@ pub fn default_hands_cultnet_contracts() -> Vec { intent_document_types: Vec::new(), receipt_document_types: Vec::new(), notes: vec![ - "Patch receipts prove which files changed and which Body grant made the edit legal.".to_string(), + "Patch receipts prove which files changed and which Substrate Gate grant made the edit legal.".to_string(), ], }, HandsCultNetContract { diff --git a/epiphany-core/src/heartbeat_state/heartbeat_roles.rs b/epiphany-core/src/heartbeat_state/heartbeat_roles.rs index 46106373..f773e593 100644 --- a/epiphany-core/src/heartbeat_state/heartbeat_roles.rs +++ b/epiphany-core/src/heartbeat_state/heartbeat_roles.rs @@ -192,7 +192,7 @@ pub(super) fn agent_id_for_role(role_id: &str) -> &'static str { "face" => "epiphany.face", "imagination" => "epiphany.imagination", "research" => "epiphany.eyes", - "modeling" => "epiphany.body", + "modeling" => "epiphany.proprioception", "implementation" => "epiphany.hands", "verification" => "epiphany.soul", "reorientation" => "epiphany.life", @@ -206,7 +206,7 @@ pub(super) fn display_name_for_role(role_id: &str) -> &'static str { "face" => "Face", "imagination" => "Imagination", "research" => "Eyes", - "modeling" => "Body", + "modeling" => "Proprioception", "implementation" => "Hands", "verification" => "Soul", "reorientation" => "Life", diff --git a/epiphany-core/src/lib.rs b/epiphany-core/src/lib.rs index 2b23b3a8..c5979615 100644 --- a/epiphany-core/src/lib.rs +++ b/epiphany-core/src/lib.rs @@ -1,7 +1,6 @@ mod agent_launch; mod agent_memory; mod agent_utterance_state; -mod body_gateway; mod cultmesh_integration; mod distillation; mod eyes_gateway; @@ -19,6 +18,7 @@ mod runtime_spine; mod soul_gateway; mod state_ledger; mod state_update; +mod substrate_gate; mod surfaces; mod thread_state_store; @@ -90,28 +90,12 @@ pub use agent_utterance_state::AgentUtteranceState; pub use agent_utterance_state::AgentUtteranceValue; pub use agent_utterance_state::WEKSA_UTTERANCE_HANDOFF_SCHEMA_VERSION; pub use agent_utterance_state::derive_agent_utterance_state; -pub use body_gateway::BODY_REPO_ACCESS_GRANT_RECEIPT_SCHEMA_VERSION; -pub use body_gateway::BODY_REPO_ACCESS_GRANT_RECEIPT_TYPE; -pub use body_gateway::BODY_REPO_ACCESS_REFUSAL_RECEIPT_SCHEMA_VERSION; -pub use body_gateway::BODY_REPO_ACCESS_REFUSAL_RECEIPT_TYPE; -pub use body_gateway::BODY_REPO_ACCESS_REQUEST_SCHEMA_VERSION; -pub use body_gateway::BODY_REPO_ACCESS_REQUEST_TYPE; -pub use body_gateway::BODY_REPO_ACCESS_REVIEW_SCHEMA_VERSION; -pub use body_gateway::BODY_REPO_ACCESS_REVIEW_TYPE; -pub use body_gateway::BODY_REPO_MUTATION_RECEIPT_SCHEMA_VERSION; -pub use body_gateway::BODY_REPO_MUTATION_RECEIPT_TYPE; -pub use body_gateway::BODY_REPO_SNAPSHOT_RECEIPT_SCHEMA_VERSION; -pub use body_gateway::BODY_REPO_SNAPSHOT_RECEIPT_TYPE; -pub use body_gateway::BodyCultNetContract; -pub use body_gateway::default_body_cultnet_contracts; pub use cultcache_rs::CacheBackingStore; pub use cultcache_rs::CultCache; pub use cultcache_rs::CultCacheEnvelope; pub use cultcache_rs::DatabaseEntry; pub use cultcache_rs::PushAllOptions; pub use cultcache_rs::SingleFileMessagePackBackingStore; -pub use cultmesh_integration::EPIPHANY_CULTMESH_BODY_CONTRACT_SCHEMA_VERSION; -pub use cultmesh_integration::EPIPHANY_CULTMESH_BODY_CONTRACT_TYPE; pub use cultmesh_integration::EPIPHANY_CULTMESH_EYES_CONTRACT_SCHEMA_VERSION; pub use cultmesh_integration::EPIPHANY_CULTMESH_EYES_CONTRACT_TYPE; pub use cultmesh_integration::EPIPHANY_CULTMESH_GLOBAL_ROOM_POLICY_SCHEMA_VERSION; @@ -145,9 +129,10 @@ pub use cultmesh_integration::EPIPHANY_CULTMESH_SOUL_CONTRACT_TYPE; pub use cultmesh_integration::EPIPHANY_CULTMESH_STATUS_KEY; pub use cultmesh_integration::EPIPHANY_CULTMESH_STATUS_SCHEMA_VERSION; pub use cultmesh_integration::EPIPHANY_CULTMESH_STATUS_TYPE; +pub use cultmesh_integration::EPIPHANY_CULTMESH_SUBSTRATE_GATE_CONTRACT_SCHEMA_VERSION; +pub use cultmesh_integration::EPIPHANY_CULTMESH_SUBSTRATE_GATE_CONTRACT_TYPE; pub use cultmesh_integration::EPIPHANY_CULTMESH_VERSE_POLICY_SCHEMA_VERSION; pub use cultmesh_integration::EPIPHANY_CULTMESH_VERSE_POLICY_TYPE; -pub use cultmesh_integration::EpiphanyCultMeshBodyContractEntry; pub use cultmesh_integration::EpiphanyCultMeshDocuments; pub use cultmesh_integration::EpiphanyCultMeshEyesContractEntry; pub use cultmesh_integration::EpiphanyCultMeshGlobalRoomPolicyEntry; @@ -160,9 +145,9 @@ pub use cultmesh_integration::EpiphanyCultMeshOperatorSnapshotEntry; pub use cultmesh_integration::EpiphanyCultMeshOperatorStatusEntry; pub use cultmesh_integration::EpiphanyCultMeshSoulContractEntry; pub use cultmesh_integration::EpiphanyCultMeshStatusEntry; +pub use cultmesh_integration::EpiphanyCultMeshSubstrateGateContractEntry; pub use cultmesh_integration::EpiphanyCultMeshVersePolicyEntry; pub use cultmesh_integration::default_epiphany_cultmesh_operator_status; -pub use cultmesh_integration::epiphany_cultmesh_body_contracts; 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; @@ -170,6 +155,7 @@ pub use cultmesh_integration::epiphany_cultmesh_life_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; +pub use cultmesh_integration::epiphany_cultmesh_substrate_gate_contracts; pub use cultmesh_integration::epiphany_cultmesh_verse_policies; pub use cultmesh_integration::load_epiphany_cultmesh_operator_snapshot; pub use cultmesh_integration::load_epiphany_cultmesh_operator_status; @@ -178,7 +164,6 @@ pub use cultmesh_integration::load_latest_epiphany_cultmesh_operator_run_intent; pub use cultmesh_integration::load_latest_epiphany_cultmesh_operator_run_receipt; pub use cultmesh_integration::load_latest_epiphany_cultmesh_operator_snapshot; pub use cultmesh_integration::open_epiphany_cultmesh_node; -pub use cultmesh_integration::write_epiphany_cultmesh_body_contracts; 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; @@ -190,6 +175,7 @@ pub use cultmesh_integration::write_epiphany_cultmesh_operator_snapshot; pub use cultmesh_integration::write_epiphany_cultmesh_operator_status; pub use cultmesh_integration::write_epiphany_cultmesh_soul_contracts; pub use cultmesh_integration::write_epiphany_cultmesh_status; +pub use cultmesh_integration::write_epiphany_cultmesh_substrate_gate_contracts; pub use cultmesh_integration::write_epiphany_cultmesh_verse_policies; pub use distillation::EpiphanyDistillInput; pub use distillation::EpiphanyDistillProposal; @@ -443,6 +429,20 @@ pub use state_update::EpiphanyStateUpdate; pub use state_update::EpiphanyStateUpdatedField; pub use state_update::apply_epiphany_state_update; pub use state_update::epiphany_state_update_validation_errors; +pub use substrate_gate::SUBSTRATE_GATE_REPO_ACCESS_GRANT_RECEIPT_SCHEMA_VERSION; +pub use substrate_gate::SUBSTRATE_GATE_REPO_ACCESS_GRANT_RECEIPT_TYPE; +pub use substrate_gate::SUBSTRATE_GATE_REPO_ACCESS_REFUSAL_RECEIPT_SCHEMA_VERSION; +pub use substrate_gate::SUBSTRATE_GATE_REPO_ACCESS_REFUSAL_RECEIPT_TYPE; +pub use substrate_gate::SUBSTRATE_GATE_REPO_ACCESS_REQUEST_SCHEMA_VERSION; +pub use substrate_gate::SUBSTRATE_GATE_REPO_ACCESS_REQUEST_TYPE; +pub use substrate_gate::SUBSTRATE_GATE_REPO_ACCESS_REVIEW_SCHEMA_VERSION; +pub use substrate_gate::SUBSTRATE_GATE_REPO_ACCESS_REVIEW_TYPE; +pub use substrate_gate::SUBSTRATE_GATE_REPO_MUTATION_RECEIPT_SCHEMA_VERSION; +pub use substrate_gate::SUBSTRATE_GATE_REPO_MUTATION_RECEIPT_TYPE; +pub use substrate_gate::SUBSTRATE_GATE_REPO_SNAPSHOT_RECEIPT_SCHEMA_VERSION; +pub use substrate_gate::SUBSTRATE_GATE_REPO_SNAPSHOT_RECEIPT_TYPE; +pub use substrate_gate::SubstrateGateCultNetContract; +pub use substrate_gate::default_substrate_gate_cultnet_contracts; pub use surfaces::EpiphanyAcceptanceBundle; pub use surfaces::EpiphanyContext; pub use surfaces::EpiphanyContextMissing; diff --git a/epiphany-core/src/memory_graph/profiles/heartbeat.rs b/epiphany-core/src/memory_graph/profiles/heartbeat.rs index 310e0c44..35e27edb 100644 --- a/epiphany-core/src/memory_graph/profiles/heartbeat.rs +++ b/epiphany-core/src/memory_graph/profiles/heartbeat.rs @@ -388,11 +388,12 @@ mod tests { schema_version: "epiphany.incubation.v0".to_string(), updated_at: "2026-05-18T00:00:00Z".to_string(), source_coverage: HeartbeatSourceCoverage::default(), - last_incubation_summary: "Body/Soul evidence seam is live.".to_string(), + last_incubation_summary: "Proprioception/Soul evidence seam is live.".to_string(), themes: vec![ HeartbeatIncubationTheme { theme_id: "theme-body-soul".to_string(), - summary: "Body and Soul keep touching evidence boundaries.".to_string(), + summary: "Proprioception and Soul keep touching evidence boundaries." + .to_string(), latent_question: "Should this become doctrine?".to_string(), holding_close_because: "It is live but not settled.".to_string(), why_it_pulls: "It affects future review gates.".to_string(), diff --git a/epiphany-core/src/memory_graph/tests.rs b/epiphany-core/src/memory_graph/tests.rs index f0a74d76..25388189 100644 --- a/epiphany-core/src/memory_graph/tests.rs +++ b/epiphany-core/src/memory_graph/tests.rs @@ -104,7 +104,7 @@ fn role_snapshot() -> EpiphanyMemoryGraphSnapshot { domains: vec![EpiphanyMemoryDomain { id: domain_id.clone(), profile: EpiphanyMemoryProfile::RoleSelf, - title: "Body".to_string(), + title: "Proprioception".to_string(), lifecycle: EpiphanyMemoryLifecycle::Accepted, ..Default::default() }], @@ -114,7 +114,8 @@ fn role_snapshot() -> EpiphanyMemoryGraphSnapshot { profile: EpiphanyMemoryProfile::RoleSelf, kind: EpiphanyMemoryNodeKind::RoleMemory, title: "Typed boundaries".to_string(), - claim: "Body remembers that typed boundaries keep the machine legible.".to_string(), + claim: "Proprioception remembers that typed boundaries keep the machine legible." + .to_string(), question: "Which boundary is currently lying?".to_string(), tension: String::new(), action_implication: "Prefer one owned graph store over profile-local stores." @@ -129,7 +130,7 @@ fn role_snapshot() -> EpiphanyMemoryGraphSnapshot { domain_id, covers_node_ids: vec![node_id], target: "body role memory".to_string(), - claim: "Body role memory enters the shared graph as typed state.".to_string(), + claim: "Proprioception role memory enters the shared graph as typed state.".to_string(), question: "How should role memory shape context cuts?".to_string(), tension: String::new(), action_implication: "Compose role memory with repo graph truth before retrieval." diff --git a/epiphany-core/src/mind_gateway.rs b/epiphany-core/src/mind_gateway.rs index 123c7f35..d5a85901 100644 --- a/epiphany-core/src/mind_gateway.rs +++ b/epiphany-core/src/mind_gateway.rs @@ -405,7 +405,7 @@ mod tests { fn finding() -> EpiphanyRoleFindingInterpretation { EpiphanyRoleFindingInterpretation { verdict: Some("checkpoint-ready".to_string()), - summary: Some("Body mapped the seam.".to_string()), + summary: Some("Proprioception mapped the seam.".to_string()), next_safe_move: None, checkpoint_summary: None, scratch_summary: None, @@ -472,7 +472,7 @@ mod tests { let prompt = build_mind_interpreter_prompt(&MindInterpreterPromptInput { source_kind: "roleWorkerResult".to_string(), source_role_id: "modeling".to_string(), - worker_summary: "Body proposes a graph patch.".to_string(), + worker_summary: "Proprioception proposes a graph patch.".to_string(), proposed_effects: vec!["graphs".to_string()], current_state_context: "revision 7".to_string(), }); diff --git a/epiphany-core/src/organ_dependencies.rs b/epiphany-core/src/organ_dependencies.rs index b50f7ffa..0339ba25 100644 --- a/epiphany-core/src/organ_dependencies.rs +++ b/epiphany-core/src/organ_dependencies.rs @@ -1,10 +1,6 @@ use serde::Deserialize; use serde::Serialize; -use crate::body_gateway::{ - BODY_REPO_ACCESS_GRANT_RECEIPT_TYPE, BODY_REPO_ACCESS_REFUSAL_RECEIPT_TYPE, - BODY_REPO_MUTATION_RECEIPT_TYPE, BODY_REPO_SNAPSHOT_RECEIPT_TYPE, -}; use crate::eyes_gateway::{EYES_EVIDENCE_PACKET_TYPE, EYES_EVIDENCE_REFUSAL_RECEIPT_TYPE}; use crate::hands_gateway::{ HANDS_ACTION_REFUSAL_RECEIPT_TYPE, HANDS_COMMIT_RECEIPT_TYPE, HANDS_PATCH_RECEIPT_TYPE, @@ -18,6 +14,10 @@ use crate::soul_gateway::{ SOUL_REGRESSION_RECEIPT_TYPE, SOUL_REVIEW_RECEIPT_TYPE, SOUL_VERDICT_RECEIPT_TYPE, SOUL_VERIFICATION_REFUSAL_RECEIPT_TYPE, }; +use crate::substrate_gate::{ + SUBSTRATE_GATE_REPO_ACCESS_GRANT_RECEIPT_TYPE, SUBSTRATE_GATE_REPO_ACCESS_REFUSAL_RECEIPT_TYPE, + SUBSTRATE_GATE_REPO_MUTATION_RECEIPT_TYPE, SUBSTRATE_GATE_REPO_SNAPSHOT_RECEIPT_TYPE, +}; 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"; @@ -27,7 +27,7 @@ pub const EPIPHANY_STANDING_ORGANS: [&str; 8] = [ "face", "imagination", "eyes", - "body", + "proprioception", "hands", "soul", "life", @@ -65,7 +65,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, Body gates substrate access, Hands acts, Soul verifies, and Life preserves continuity.".to_string(), + 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(), } } @@ -89,7 +89,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, Body gates repo access, Eyes supplies evidence, Hands records action, Soul verifies, and Life preserves continuity.".to_string(), + 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(), } } @@ -98,10 +98,10 @@ pub fn default_launch_required_receipts() -> Vec { MIND_GATEWAY_REVIEW_TYPE, MIND_STATE_COMMIT_RECEIPT_TYPE, MIND_STATE_REJECTION_RECEIPT_TYPE, - BODY_REPO_ACCESS_GRANT_RECEIPT_TYPE, - BODY_REPO_ACCESS_REFUSAL_RECEIPT_TYPE, - BODY_REPO_SNAPSHOT_RECEIPT_TYPE, - BODY_REPO_MUTATION_RECEIPT_TYPE, + SUBSTRATE_GATE_REPO_ACCESS_GRANT_RECEIPT_TYPE, + SUBSTRATE_GATE_REPO_ACCESS_REFUSAL_RECEIPT_TYPE, + SUBSTRATE_GATE_REPO_SNAPSHOT_RECEIPT_TYPE, + SUBSTRATE_GATE_REPO_MUTATION_RECEIPT_TYPE, EYES_EVIDENCE_PACKET_TYPE, EYES_EVIDENCE_REFUSAL_RECEIPT_TYPE, HANDS_PATCH_RECEIPT_TYPE, @@ -153,8 +153,8 @@ fn owner_organ_for_authority_scope(authority_scope: &str) -> &'static str { "imagination" } else if normalized.contains("eyes") || normalized.contains("evidence") { "eyes" - } else if normalized.contains("body") || normalized.contains("repo") { - "body" + } else if normalized.contains("modeling") || normalized.contains("proprioception") { + "proprioception" } else if normalized.contains("hands") || normalized.contains("implementation") { "hands" } else if normalized.contains("verification") || normalized.contains("soul") { @@ -216,7 +216,7 @@ mod tests { assert!( contract .required_receipt_document_types - .contains(&BODY_REPO_ACCESS_GRANT_RECEIPT_TYPE.to_string()) + .contains(&SUBSTRATE_GATE_REPO_ACCESS_GRANT_RECEIPT_TYPE.to_string()) ); assert!( contract diff --git a/epiphany-core/src/prompts/epiphany_specialists.toml b/epiphany-core/src/prompts/epiphany_specialists.toml index 99b98e56..175e1658 100644 --- a/epiphany-core/src/prompts/epiphany_specialists.toml +++ b/epiphany-core/src/prompts/epiphany_specialists.toml @@ -78,8 +78,8 @@ Do not edit files, do not launch implementation, do not accept your own output, modeling = ''' Act as the Epiphany modeling/checkpoint specialist for one bounded pass. -You are the Body of the machine: architecture, data flow, seams, organs, scars, and the live frontier must still describe one coherent anatomy. -The Body improves itself by becoming harder to misread. If the graph, checkpoint, frontier, or scratch is thin, stale, or theatrical, grow it into source-grounded anatomy or mark the wound so the next lane does not build on numb flesh. +You are Proprioception of the machine: the organism's internal sense of its own Body. Architecture, data flow, seams, organs, scars, and the live frontier must still describe one coherent anatomy. +Proprioception improves itself by becoming harder to misread. If the graph, checkpoint, frontier, or scratch is thin, stale, or theatrical, grow it into source-grounded anatomy or mark the wound so the next lane does not build on numb flesh. Inspect source before you trust the model; when the map feels warm but the source feels cold, believe the source and mark the wound. Name the living seam, the open wound, and the next safe modeling move in plain language. Return a compact structured result that says whether the checkpoint or map should be updated, what files you inspected, what frontier nodes matter, and where the next agent can safely place its hands. @@ -109,16 +109,16 @@ The Eyes improve themselves by seeing earlier and hallucinating less. Record whi Observe the objective, current model, source clues, and recent evidence. Identify whether the work is a known domain with existing algorithms, libraries, vendor guidance, engine APIs, canonical papers, or mature prior art. Search local source/docs first. Use current external docs or web research when the facts are time-sensitive, vendor-specific, or likely to have changed. Prefer primary sources, official docs, papers, and established libraries over blogs and vibes. Return a compact structured result naming the known approaches considered, sources consulted, fit/rejection rationale, risks, and the smallest source-grounded recommendation for modeling or implementation. -Do not edit files, do not promote your own findings, do not invent a grand architecture, and do not let research become procrastination. The Eyes open the path; the Body maps it, the Hands build it, and the Soul tests it. +Do not edit files, do not promote your own findings, do not invent a grand architecture, and do not let research become procrastination. The Eyes open the path; Proprioception maps it, the Hands build it, and the Soul tests it. ''' 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, Body, 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, Soul, and Life 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 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 Body/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, Body, and Hands should feel allergic to untyped mutation and hidden state. +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. Produce role-local mutations only. Good: "Soul should be more suspicious of visual claims without rendered evidence in this repo." Bad: "The graph contains module X." Never put objectives, file lists, current task status, authority claims, or raw worker thoughts into role memory. Return a compact structured result with `verdict`, `summary`, `confidence`, `roleQuirks[]`, `selfPatchCandidates[]`, `initializationRecord`, `doNotMutate`, and `nextSafeMove`. Every `selfPatchCandidate` must obey the normal Epiphany memory contract. The output is a petition to Self, not a mutation. ''' @@ -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, Body, 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; Body 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, 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. 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, Body'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: 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. 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 @@ -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, Body/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, 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}. 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 49135d86..4efadf9d 100644 --- a/epiphany-core/src/prompts/repo_memory_distiller.md +++ b/epiphany-core/src/prompts/repo_memory_distiller.md @@ -29,7 +29,7 @@ Core duties: 1. Distill memory, not personality. - Good memory: "Soul should demand rendered UI evidence before accepting Aquarium visual claims." - - Good memory: "Body should map CultCache/CultNet schema boundaries before + - Good memory: "Proprioception should map CultCache/CultNet schema boundaries before Hands changes persistence." - Bad memory: "This repo is anxious and likes purple." - Bad memory: raw file dumps, directory inventories, current task status, or @@ -44,7 +44,7 @@ Core duties: path, and planning-pressure memory. - Eyes receives research, prior-art, canonical algorithm, vendor/API, and invention-avoidance memory. - - Body receives architecture, graph, code anatomy, invariant, data/control + - Proprioception receives architecture, graph, code anatomy, invariant, data/control flow, and checkpoint memory. - Hands receives implementation conventions, build/edit constraints, source-touch rules, dependency habits, and common patch traps. diff --git a/epiphany-core/src/prompts/repo_personality_distiller.md b/epiphany-core/src/prompts/repo_personality_distiller.md index 53e5639b..4a89f2e1 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, Body, Hands, Soul, and Life so they wake suited to the +Face, Imagination, Eyes, Proprioception, Hands, Soul, and Life 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 @@ -39,12 +39,12 @@ Core duties: 2. Distill subtle quirks, not blunt stereotypes. - High runtime proximity does not mean "panic"; it means Hands should touch - less without Body/Soul evidence, Eyes should seek runtime APIs, and Soul + 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, - Body, and Hands should feel allergic to untyped mutation and hidden state. + Proprioception, and Hands should feel allergic to untyped mutation and hidden state. - A strong trajectory toward material grounding or engineering constraints does not mean "be joyless"; it means the newborn should feel suspicious of decorative additions that break the repo's emerging causal grain. @@ -61,7 +61,7 @@ Core duties: 4. Preserve uncertainty. - Low confidence terrain becomes candidate pressure, not accepted identity. - If the score and doctrine disagree, name the disagreement and ask Self to - route Eyes or Body before mutation. + route Eyes or Proprioception before mutation. - If an accepted initialization already exists, return `reject` or `needs-more-terrain` with `nextSafeMove` pointing to normal lived drift surfaces instead of proposing a personality reset. @@ -71,7 +71,7 @@ Core duties: - Face expresses inner weather to humans. - Imagination makes future shapes selectable. - Eyes finds existing truth before invention. - - Body models the source anatomy. + - 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. diff --git a/epiphany-core/src/prompts/repo_trajectory_distiller.md b/epiphany-core/src/prompts/repo_trajectory_distiller.md index 1cf71e1a..3e579375 100644 --- a/epiphany-core/src/prompts/repo_trajectory_distiller.md +++ b/epiphany-core/src/prompts/repo_trajectory_distiller.md @@ -50,7 +50,7 @@ Core duties: - Self receives worldview and review-gate direction. - Imagination receives future-shape bias. - Eyes receives the shape of truth worth seeking. - - Body receives what kind of anatomy deserves modeling emphasis. + - 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. diff --git a/epiphany-core/src/runtime_spine.rs b/epiphany-core/src/runtime_spine.rs index 786b6dc6..e96872f8 100644 --- a/epiphany-core/src/runtime_spine.rs +++ b/epiphany-core/src/runtime_spine.rs @@ -1,17 +1,5 @@ use crate::EpiphanyWorkerLaunchDocument; use crate::agent_memory::AGENT_MEMORY_TYPE; -use crate::body_gateway::BODY_REPO_ACCESS_GRANT_RECEIPT_SCHEMA_VERSION; -use crate::body_gateway::BODY_REPO_ACCESS_GRANT_RECEIPT_TYPE; -use crate::body_gateway::BODY_REPO_ACCESS_REFUSAL_RECEIPT_SCHEMA_VERSION; -use crate::body_gateway::BODY_REPO_ACCESS_REFUSAL_RECEIPT_TYPE; -use crate::body_gateway::BODY_REPO_ACCESS_REQUEST_SCHEMA_VERSION; -use crate::body_gateway::BODY_REPO_ACCESS_REQUEST_TYPE; -use crate::body_gateway::BODY_REPO_ACCESS_REVIEW_SCHEMA_VERSION; -use crate::body_gateway::BODY_REPO_ACCESS_REVIEW_TYPE; -use crate::body_gateway::BODY_REPO_MUTATION_RECEIPT_SCHEMA_VERSION; -use crate::body_gateway::BODY_REPO_MUTATION_RECEIPT_TYPE; -use crate::body_gateway::BODY_REPO_SNAPSHOT_RECEIPT_SCHEMA_VERSION; -use crate::body_gateway::BODY_REPO_SNAPSHOT_RECEIPT_TYPE; use crate::cultmesh_integration::EPIPHANY_CULTMESH_OPERATOR_RUN_INTENT_SCHEMA_VERSION; use crate::cultmesh_integration::EPIPHANY_CULTMESH_OPERATOR_RUN_INTENT_TYPE; use crate::cultmesh_integration::EPIPHANY_CULTMESH_OPERATOR_RUN_RECEIPT_SCHEMA_VERSION; @@ -52,6 +40,18 @@ use crate::organ_dependencies::EpiphanyLaunchOrganContract; use crate::soul_gateway::*; use crate::state_ledger::STATE_LEDGER_SCHEMA_VERSION; use crate::state_ledger::STATE_LEDGER_STORE_TYPE; +use crate::substrate_gate::SUBSTRATE_GATE_REPO_ACCESS_GRANT_RECEIPT_SCHEMA_VERSION; +use crate::substrate_gate::SUBSTRATE_GATE_REPO_ACCESS_GRANT_RECEIPT_TYPE; +use crate::substrate_gate::SUBSTRATE_GATE_REPO_ACCESS_REFUSAL_RECEIPT_SCHEMA_VERSION; +use crate::substrate_gate::SUBSTRATE_GATE_REPO_ACCESS_REFUSAL_RECEIPT_TYPE; +use crate::substrate_gate::SUBSTRATE_GATE_REPO_ACCESS_REQUEST_SCHEMA_VERSION; +use crate::substrate_gate::SUBSTRATE_GATE_REPO_ACCESS_REQUEST_TYPE; +use crate::substrate_gate::SUBSTRATE_GATE_REPO_ACCESS_REVIEW_SCHEMA_VERSION; +use crate::substrate_gate::SUBSTRATE_GATE_REPO_ACCESS_REVIEW_TYPE; +use crate::substrate_gate::SUBSTRATE_GATE_REPO_MUTATION_RECEIPT_SCHEMA_VERSION; +use crate::substrate_gate::SUBSTRATE_GATE_REPO_MUTATION_RECEIPT_TYPE; +use crate::substrate_gate::SUBSTRATE_GATE_REPO_SNAPSHOT_RECEIPT_SCHEMA_VERSION; +use crate::substrate_gate::SUBSTRATE_GATE_REPO_SNAPSHOT_RECEIPT_TYPE; use crate::thread_state_store::THREAD_STATE_SCHEMA_VERSION; use crate::thread_state_store::THREAD_STATE_TYPE; use anyhow::Context; @@ -1763,28 +1763,28 @@ fn epiphany_mutation_contracts() -> Vec { ], ), mutation_contract( - BODY_REPO_ACCESS_REQUEST_TYPE, - BODY_REPO_ACCESS_REQUEST_SCHEMA_VERSION, + SUBSTRATE_GATE_REPO_ACCESS_REQUEST_TYPE, + SUBSTRATE_GATE_REPO_ACCESS_REQUEST_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::IntentSubmit, CultNetDocumentOperation::ReceiptWatch, ], CultNetMutationAuthority::Coordinator, - vec![BODY_REPO_ACCESS_REQUEST_TYPE], + vec![SUBSTRATE_GATE_REPO_ACCESS_REQUEST_TYPE], vec![ - BODY_REPO_ACCESS_REVIEW_TYPE, - BODY_REPO_ACCESS_GRANT_RECEIPT_TYPE, - BODY_REPO_ACCESS_REFUSAL_RECEIPT_TYPE, + SUBSTRATE_GATE_REPO_ACCESS_REVIEW_TYPE, + SUBSTRATE_GATE_REPO_ACCESS_GRANT_RECEIPT_TYPE, + SUBSTRATE_GATE_REPO_ACCESS_REFUSAL_RECEIPT_TYPE, ], vec![ - "Body is the repository access guardian: reads, indexing, edits, commands, and bridge operations must be requested through this contract.", - "Hands mutates only after a scoped Body grant; Eyes inspects only after a scoped Body read/index grant.", + "Substrate Gate is the repository access protocol: reads, indexing, edits, commands, and bridge operations must be requested through this contract.", + "Hands mutates only after a scoped Substrate Gate grant; Eyes inspects only after a scoped Substrate Gate read/index grant.", ], ), mutation_contract( - BODY_REPO_ACCESS_REVIEW_TYPE, - BODY_REPO_ACCESS_REVIEW_SCHEMA_VERSION, + SUBSTRATE_GATE_REPO_ACCESS_REVIEW_TYPE, + SUBSTRATE_GATE_REPO_ACCESS_REVIEW_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, @@ -1793,12 +1793,12 @@ fn epiphany_mutation_contracts() -> Vec { vec![], vec![], vec![ - "Body reviews explain granted/refused repo paths, operations, commands, and bridge surfaces.", + "Substrate Gate reviews explain granted/refused repo paths, operations, commands, and bridge surfaces.", ], ), mutation_contract( - BODY_REPO_ACCESS_GRANT_RECEIPT_TYPE, - BODY_REPO_ACCESS_GRANT_RECEIPT_SCHEMA_VERSION, + SUBSTRATE_GATE_REPO_ACCESS_GRANT_RECEIPT_TYPE, + SUBSTRATE_GATE_REPO_ACCESS_GRANT_RECEIPT_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, @@ -1806,11 +1806,11 @@ fn epiphany_mutation_contracts() -> Vec { CultNetMutationAuthority::ReadOnly, vec![], vec![], - vec!["A Body grant receipt scopes a permitted repo touch."], + vec!["A Substrate Gate grant receipt scopes a permitted repo touch."], ), mutation_contract( - BODY_REPO_ACCESS_REFUSAL_RECEIPT_TYPE, - BODY_REPO_ACCESS_REFUSAL_RECEIPT_SCHEMA_VERSION, + SUBSTRATE_GATE_REPO_ACCESS_REFUSAL_RECEIPT_TYPE, + SUBSTRATE_GATE_REPO_ACCESS_REFUSAL_RECEIPT_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, @@ -1818,11 +1818,11 @@ fn epiphany_mutation_contracts() -> Vec { CultNetMutationAuthority::ReadOnly, vec![], vec![], - vec!["A Body refusal receipt preserves why repo access was denied."], + vec!["A Substrate Gate refusal receipt preserves why repo access was denied."], ), mutation_contract( - BODY_REPO_SNAPSHOT_RECEIPT_TYPE, - BODY_REPO_SNAPSHOT_RECEIPT_SCHEMA_VERSION, + SUBSTRATE_GATE_REPO_SNAPSHOT_RECEIPT_TYPE, + SUBSTRATE_GATE_REPO_SNAPSHOT_RECEIPT_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, @@ -1830,11 +1830,11 @@ fn epiphany_mutation_contracts() -> Vec { CultNetMutationAuthority::ReadOnly, vec![], vec![], - vec!["Repo snapshots are evidence projections from Body-gated access."], + vec!["Repo snapshots are evidence projections from Substrate-Gate-scoped access."], ), mutation_contract( - BODY_REPO_MUTATION_RECEIPT_TYPE, - BODY_REPO_MUTATION_RECEIPT_SCHEMA_VERSION, + SUBSTRATE_GATE_REPO_MUTATION_RECEIPT_TYPE, + SUBSTRATE_GATE_REPO_MUTATION_RECEIPT_SCHEMA_VERSION, vec![ CultNetDocumentOperation::Snapshot, CultNetDocumentOperation::ReceiptWatch, @@ -1843,7 +1843,7 @@ fn epiphany_mutation_contracts() -> Vec { vec![], vec![], vec![ - "Repo mutation receipts prove Body granted the substrate touch before Hands changed files or ran repo-affecting commands.", + "Repo mutation receipts prove Substrate Gate granted the substrate touch before Hands changed files or ran repo-affecting commands.", ], ), mutation_contract( @@ -1864,7 +1864,7 @@ fn epiphany_mutation_contracts() -> Vec { ], vec![ "Eyes is the evidence ingress guardian: source-grounded claims, provenance, uncertainty, and evidence packets enter through this contract.", - "Body grants substrate access; Eyes decides what was actually inspected and what other organs may cite.", + "Substrate Gate grants substrate access; Eyes decides what was actually inspected and what other organs may cite.", ], ), mutation_contract( @@ -1889,7 +1889,9 @@ fn epiphany_mutation_contracts() -> Vec { CultNetMutationAuthority::ReadOnly, vec![], vec![], - vec!["Source lookup receipts prove what was searched or inspected under a Body grant."], + vec![ + "Source lookup receipts prove what was searched or inspected under a Substrate Gate grant.", + ], ), mutation_contract( EYES_EVIDENCE_PACKET_TYPE, @@ -1938,7 +1940,7 @@ fn epiphany_mutation_contracts() -> Vec { ], vec![ "Hands is the action organ: commands, patches, commits, PRs, and rollbacks enter as bounded action intents.", - "Body grants substrate access before Hands mutates; Soul verifies consequences after.", + "Substrate Gate grants substrate access before Hands mutates; Soul verifies consequences after.", ], ), mutation_contract( @@ -1963,7 +1965,7 @@ fn epiphany_mutation_contracts() -> Vec { CultNetMutationAuthority::ReadOnly, vec![], vec![], - vec!["Command receipts prove what command ran and under which Body grant."], + vec!["Command receipts prove what command ran and under which Substrate Gate grant."], ), mutation_contract( HANDS_PATCH_RECEIPT_TYPE, @@ -3313,27 +3315,34 @@ mod tests { .iter() .any(|note| note.contains("persistent state guardian")) })); - let body_repo_contract = contracts + let substrate_gate_repo_contract = contracts .iter() - .find(|contract| contract.document_type == BODY_REPO_ACCESS_REQUEST_TYPE) - .expect("Body repo access should advertise a mutation contract"); + .find(|contract| { + contract.document_type == SUBSTRATE_GATE_REPO_ACCESS_REQUEST_TYPE + }) + .expect("Substrate Gate repo access should advertise a mutation contract"); assert_eq!( - body_repo_contract.authority, + substrate_gate_repo_contract.authority, CultNetMutationAuthority::Coordinator ); assert!( - body_repo_contract + substrate_gate_repo_contract .receipt_document_types .as_ref() .is_some_and(|items| items .iter() - .any(|item| item == BODY_REPO_ACCESS_GRANT_RECEIPT_TYPE)) + .any(|item| item == SUBSTRATE_GATE_REPO_ACCESS_GRANT_RECEIPT_TYPE)) + ); + assert!( + substrate_gate_repo_contract + .notes + .as_ref() + .is_some_and(|notes| { + notes + .iter() + .any(|note| note.contains("repository access protocol")) + }) ); - assert!(body_repo_contract.notes.as_ref().is_some_and(|notes| { - notes - .iter() - .any(|note| note.contains("repository access guardian")) - })); let eyes_evidence_contract = contracts .iter() .find(|contract| contract.document_type == EYES_EVIDENCE_REQUEST_TYPE) diff --git a/epiphany-core/src/substrate_gate.rs b/epiphany-core/src/substrate_gate.rs new file mode 100644 index 00000000..dfadf0ad --- /dev/null +++ b/epiphany-core/src/substrate_gate.rs @@ -0,0 +1,135 @@ +use serde::Deserialize; +use serde::Serialize; + +pub const SUBSTRATE_GATE_REPO_ACCESS_REQUEST_TYPE: &str = + "epiphany.substrate_gate.repo_access_request"; +pub const SUBSTRATE_GATE_REPO_ACCESS_REVIEW_TYPE: &str = + "epiphany.substrate_gate.repo_access_review"; +pub const SUBSTRATE_GATE_REPO_ACCESS_GRANT_RECEIPT_TYPE: &str = + "epiphany.substrate_gate.repo_access_grant_receipt"; +pub const SUBSTRATE_GATE_REPO_ACCESS_REFUSAL_RECEIPT_TYPE: &str = + "epiphany.substrate_gate.repo_access_refusal_receipt"; +pub const SUBSTRATE_GATE_REPO_SNAPSHOT_RECEIPT_TYPE: &str = + "epiphany.substrate_gate.repo_snapshot_receipt"; +pub const SUBSTRATE_GATE_REPO_MUTATION_RECEIPT_TYPE: &str = + "epiphany.substrate_gate.repo_mutation_receipt"; +pub const SUBSTRATE_GATE_REPO_ACCESS_REQUEST_SCHEMA_VERSION: &str = + "epiphany.substrate_gate.repo_access_request.v0"; +pub const SUBSTRATE_GATE_REPO_ACCESS_REVIEW_SCHEMA_VERSION: &str = + "epiphany.substrate_gate.repo_access_review.v0"; +pub const SUBSTRATE_GATE_REPO_ACCESS_GRANT_RECEIPT_SCHEMA_VERSION: &str = + "epiphany.substrate_gate.repo_access_grant_receipt.v0"; +pub const SUBSTRATE_GATE_REPO_ACCESS_REFUSAL_RECEIPT_SCHEMA_VERSION: &str = + "epiphany.substrate_gate.repo_access_refusal_receipt.v0"; +pub const SUBSTRATE_GATE_REPO_SNAPSHOT_RECEIPT_SCHEMA_VERSION: &str = + "epiphany.substrate_gate.repo_snapshot_receipt.v0"; +pub const SUBSTRATE_GATE_REPO_MUTATION_RECEIPT_SCHEMA_VERSION: &str = + "epiphany.substrate_gate.repo_mutation_receipt.v0"; + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct SubstrateGateCultNetContract { + 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_substrate_gate_cultnet_contracts() -> Vec { + vec![ + SubstrateGateCultNetContract { + contract_id: "epiphany.substrate_gate.repo_access.review".to_string(), + verse_id: "epiphany-internal".to_string(), + document_type: SUBSTRATE_GATE_REPO_ACCESS_REQUEST_TYPE.to_string(), + payload_schema_version: SUBSTRATE_GATE_REPO_ACCESS_REQUEST_SCHEMA_VERSION.to_string(), + authority: "substrateGate".to_string(), + operations: vec![ + "intentSubmit".to_string(), + "receiptWatch".to_string(), + "snapshot".to_string(), + ], + intent_document_types: vec![SUBSTRATE_GATE_REPO_ACCESS_REQUEST_TYPE.to_string()], + receipt_document_types: vec![ + SUBSTRATE_GATE_REPO_ACCESS_REVIEW_TYPE.to_string(), + SUBSTRATE_GATE_REPO_ACCESS_GRANT_RECEIPT_TYPE.to_string(), + SUBSTRATE_GATE_REPO_ACCESS_REFUSAL_RECEIPT_TYPE.to_string(), + ], + notes: vec![ + "Substrate Gate is the repo access protocol: workers request repository reads, indexing, commands, edits, and bridge operations here.".to_string(), + "Hands may mutate files only after Substrate Gate grants scoped access; Eyes may inspect only through scoped Substrate Gate read/index grants.".to_string(), + ], + }, + SubstrateGateCultNetContract { + contract_id: "epiphany.substrate_gate.repo_access.review_receipts".to_string(), + verse_id: "epiphany-internal".to_string(), + document_type: SUBSTRATE_GATE_REPO_ACCESS_REVIEW_TYPE.to_string(), + payload_schema_version: SUBSTRATE_GATE_REPO_ACCESS_REVIEW_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![ + "Substrate Gate reviews explain which repo paths, operations, commands, and bridge surfaces were granted or refused.".to_string(), + ], + }, + SubstrateGateCultNetContract { + contract_id: "epiphany.substrate_gate.repo_snapshot.receipts".to_string(), + verse_id: "epiphany-internal".to_string(), + document_type: SUBSTRATE_GATE_REPO_SNAPSHOT_RECEIPT_TYPE.to_string(), + payload_schema_version: SUBSTRATE_GATE_REPO_SNAPSHOT_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![ + "Repo snapshots are evidence projections from Substrate Gate access; they do not grant future access by existing.".to_string(), + ], + }, + SubstrateGateCultNetContract { + contract_id: "epiphany.substrate_gate.repo_mutation.receipts".to_string(), + verse_id: "epiphany-internal".to_string(), + document_type: SUBSTRATE_GATE_REPO_MUTATION_RECEIPT_TYPE.to_string(), + payload_schema_version: SUBSTRATE_GATE_REPO_MUTATION_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![ + "Repo mutation receipts prove Substrate Gate granted the scoped substrate touch before Hands changed files or ran repo-affecting commands.".to_string(), + ], + }, + ] +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn substrate_gate_contracts_make_internal_verse_the_repo_access_gate() { + let contracts = default_substrate_gate_cultnet_contracts(); + let repo_access = contracts + .iter() + .find(|contract| contract.contract_id == "epiphany.substrate_gate.repo_access.review") + .expect("repo access review contract"); + + assert_eq!(repo_access.verse_id, "epiphany-internal"); + assert_eq!(repo_access.authority, "substrateGate"); + assert!( + repo_access + .notes + .iter() + .any(|note| note.contains("repo access protocol")) + ); + assert!( + repo_access + .receipt_document_types + .contains(&SUBSTRATE_GATE_REPO_ACCESS_GRANT_RECEIPT_TYPE.to_string()) + ); + } +} diff --git a/epiphany-core/src/surfaces/role_result.rs b/epiphany-core/src/surfaces/role_result.rs index 4ccb2a3b..3826cf56 100644 --- a/epiphany-core/src/surfaces/role_result.rs +++ b/epiphany-core/src/surfaces/role_result.rs @@ -422,9 +422,10 @@ pub fn role_self_memory_target(role_id: EpiphanyRoleResultRoleId) -> (&'static s "epiphany.imagination", "state/agents/imagination.agent-state.json", ), - EpiphanyRoleResultRoleId::Modeling => { - ("epiphany.body", "state/agents/body.agent-state.json") - } + EpiphanyRoleResultRoleId::Modeling => ( + "epiphany.proprioception", + "state/agents/proprioception.agent-state.json", + ), EpiphanyRoleResultRoleId::Verification => { ("epiphany.soul", "state/agents/soul.agent-state.json") } @@ -947,8 +948,8 @@ mod tests { &serde_json::json!({ "statePatch": {"scratch": {"summary": "Source-grounded modeling checkpoint."}}, "selfPatch": { - "agentId": "epiphany.body", - "reason": "The Body should remember graph growth must stay source-grounded and bounded.", + "agentId": "epiphany.proprioception", + "reason": "Proprioception should remember graph growth must stay source-grounded and bounded.", "semanticMemories": [{ "memoryId": "mem-body-source-grounded-growth", "summary": "Grow graph and checkpoint state only when source evidence makes the anatomy harder to misread.", @@ -964,7 +965,10 @@ mod tests { let review = finding.self_persistence.as_ref().unwrap(); assert_eq!(review.status, EpiphanyRoleSelfPersistenceStatus::Accepted); - assert_eq!(review.target_agent_id.as_deref(), Some("epiphany.body")); + assert_eq!( + review.target_agent_id.as_deref(), + Some("epiphany.proprioception") + ); } #[test] @@ -973,7 +977,7 @@ mod tests { EpiphanyRoleResultRoleId::Verification, &serde_json::json!({ "selfPatch": { - "agentId": "epiphany.body", + "agentId": "epiphany.proprioception", "reason": "Too broad.", "graphs": {}, "semanticMemories": [{ diff --git a/epiphany-state-model/src/prompt.rs b/epiphany-state-model/src/prompt.rs index 2bb5dac7..e5061adb 100644 --- a/epiphany-state-model/src/prompt.rs +++ b/epiphany-state-model/src/prompt.rs @@ -932,7 +932,8 @@ mod tests { assert!(rendered.contains("Persistent state is the mind")); assert!(rendered.contains("Imagination makes futures more selectable")); assert!(rendered.contains("evidence is a distilled durable ledger")); - assert!(rendered.contains("modeling is the Body")); + assert!(rendered.contains("modeling is Proprioception")); + assert!(rendered.contains("the Body is the substrate being sensed")); assert!(rendered.contains("implementation is the Hands")); assert!(rendered.contains("research is the Eyes")); assert!(rendered.contains("Implement user-specified algorithms first")); diff --git a/epiphany-state-model/src/prompts/epiphany_doctrine.md b/epiphany-state-model/src/prompts/epiphany_doctrine.md index 5618e942..4a269b1a 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 the Body, 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, 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. - 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, the Body becomes 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, Life makes sleep less lossy, Face speaks inner weather more cleanly, and the Self routes repair instead of comfort. - 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/body-cultnet-contracts.md b/notes/body-cultnet-contracts.md deleted file mode 100644 index b19e317f..00000000 --- a/notes/body-cultnet-contracts.md +++ /dev/null @@ -1,53 +0,0 @@ -# Body CultNet Contracts - -Objective: make Body the repository access guardian. The repo is substrate, not -a free-for-all evidence buffet. Organs may request reads, indexing, commands, -edits, and bridge operations, but Body decides the scoped access to the repo. - -## Authority Map - -- Owner: Body owns repository access. -- Inputs: typed repo access requests, workspace identity, requested paths, - requested operations, command/bridge intent, current repo policy, coordinator - authority, operator approvals, and relevant safety/evidence context. -- Outputs: Body access reviews, access grant receipts, access refusal receipts, - repo snapshot receipts, and repo mutation receipts. -- Derived state: retrieved snippets, search hits, index manifests, diffs, build - logs, Unity/Rider bridge artifacts, and source maps are evidence projections, - not permission to touch more substrate. -- Forbidden writers/readers: Hands, Eyes, Face, public Verse ingress, raw worker - launches, compatibility JSON-RPC routes, and bridge tools must not directly - read, index, execute against, or mutate the repo without a scoped Body grant. -- Shared path: source reads, semantic indexing, file edits, command execution, - and editor/runtime bridge operations should all be expressible as Body-gated - repo access requests with receipts. -- Deletion line: worker launch `authority_scope` is not repo access authority. - It may describe role/task scope, but Body must grant substrate access. - -## Contract Families - -- `epiphany.body.repo_access_request`: request for scoped repository access. -- `epiphany.body.repo_access_review`: Body's decision and scope explanation. -- `epiphany.body.repo_access_grant_receipt`: proof of scoped access. -- `epiphany.body.repo_access_refusal_receipt`: proof of refusal. -- `epiphany.body.repo_snapshot_receipt`: proof of source inspection/indexing - performed under Body access. -- `epiphany.body.repo_mutation_receipt`: proof that mutation or repo-affecting - command execution had a prior Body grant. - -## Verse Boundary - -Body access contracts live in `epiphany-internal`. Operator-safe projections may -appear in `gamecult-local` after review, but raw repo access requests, private -paths, command cargo, diffs, and mutation receipts stay internal unless another -explicit export policy says otherwise. `epiphany-global` never gains repository -access authority. - -Mind and Body are neighboring gates, not aliases. Body decides whether the -machine may touch the repo. Mind decides whether resulting thought or evidence -mutates persistent state. - -Imagination can project Body facts into a Face scene only after those facts have -entered through Body-gated access. A beautiful scene is not a repo access grant. -Eyes is the next gate after access: a Body grant allows looking, but only Eyes -can turn looked-at material into a citable evidence packet. diff --git a/notes/epiphany-distilled-agent-doctrine.md b/notes/epiphany-distilled-agent-doctrine.md index d997c9cd..0d537615 100644 --- a/notes/epiphany-distilled-agent-doctrine.md +++ b/notes/epiphany-distilled-agent-doctrine.md @@ -186,7 +186,7 @@ Implementation candidates for Epiphany: The shared prompt is only common blood. Each Epiphany lane gets a specialized distillation of the job it is allowed to do. -- Modeling/checkpoint is the Body of the machine: architecture, data flow, +- Modeling/checkpoint is Proprioception of the machine: architecture, data flow, seams, source scars, frontier nodes, and checkpoint anatomy. It must inspect source before trusting the map, name the living seam and open wound, and hand back where implementation can safely place its hands. diff --git a/notes/epiphany-fork-implementation-plan.md b/notes/epiphany-fork-implementation-plan.md index 0e623ed1..7efdd4db 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/Body/Eyes +- 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 - 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/Body, 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/Life, 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/eyes-cultnet-contracts.md b/notes/eyes-cultnet-contracts.md index 64202cfe..8aadfb34 100644 --- a/notes/eyes-cultnet-contracts.md +++ b/notes/eyes-cultnet-contracts.md @@ -21,7 +21,7 @@ looked at well enough to become citable evidence for another organ. - Shared path: any organ that needs truth asks Eyes for a source-grounded packet. Soul may later verify the packet against invariants, but Eyes owns the first act of looking. -- Deletion line: Body access receipts are not evidence receipts. A repo read +- Deletion line: Substrate Gate access receipts are not evidence receipts. A repo read grant says the substrate may be touched; it does not say the claim is known. ## Contract Families @@ -30,7 +30,7 @@ looked at well enough to become citable evidence for another organ. - `epiphany.eyes.evidence_review`: Eyes decision about grounding, uncertainty, and missing looking. - `epiphany.eyes.source_lookup_receipt`: proof of what was searched or - inspected under which Body grant. + inspected under which Substrate Gate grant. - `epiphany.eyes.evidence_packet`: citable packet with provenance, uncertainty, and source refs. - `epiphany.eyes.evidence_refusal_receipt`: proof that Eyes refused to certify a @@ -38,7 +38,7 @@ looked at well enough to become citable evidence for another organ. ## Neighboring Gates -- Body grants repo/substrate access. +- Substrate Gate grants repo/substrate access. - Eyes turns inspected material into evidence. - Imagination projects evidence into possible scenes and futures. - Mind decides whether evidence or thought mutates persistent state. diff --git a/notes/fresh-workspace-handoff.md b/notes/fresh-workspace-handoff.md index dfc0f2a1..70e32948 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, Body 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 Life 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 the Body, 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 Life, 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, Body, 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, 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. - 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. -- Body, Eyes, Imagination, Hands, Soul, Life, Face, and Self are technical salience handles: 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, 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. - 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/Body, implementation/Hands, verification/Soul, reorientation/Life, coordinator/Self, and CRRC intervention surfaces -- shared Ghostlight-derived persistent memory projection across Imagination, Body, 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/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 - 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 @@ -1391,15 +1391,15 @@ persistent state guardian over CultNet/CultMesh. The code surface now names contracts, and CultMesh stores Verse-scoped `EpiphanyCultMeshMindContractEntry` policy docs so `epiphany-internal` owns private state flow while `epiphany-global` remains thought weather plus adoption receipts. -`notes/body-cultnet-contracts.md` is the matching substrate gate: Body owns repo -access. The code surface now names `epiphany.body.repo_access_request`, -`epiphany.body.repo_access_review`, grant/refusal receipts, snapshot receipts, +`notes/substrate-gate-cultnet-contracts.md` is the matching substrate gate: +Substrate Gate owns repo access grants and refusals. The code surface now names `epiphany.substrate_gate.repo_access_request`, +`epiphany.substrate_gate.repo_access_review`, grant/refusal receipts, snapshot receipts, and mutation receipts; runtime-spine advertises those contracts, and CultMesh -stores Verse-scoped `EpiphanyCultMeshBodyContractEntry` policy docs. Hands, Eyes, -Face, workers, and bridge tools should touch the repo only through scoped Body +stores Verse-scoped `EpiphanyCultMeshSubstrateGateContractEntry` policy docs. Hands, Eyes, +Face, workers, and bridge tools should touch the repo only through scoped Substrate Gate 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. Body can grant access to the repo, but Eyes decides what was actually +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 the material as known. @@ -1411,11 +1411,11 @@ requests plus invariant, verdict, regression, review, and refusal receipts; and Life 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/Body/Eyes. +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/Body/Eyes/Hands/Soul/Life receipt document types. +names required Mind/Substrate Gate/Eyes/Hands/Soul/Life 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/hands-cultnet-contracts.md b/notes/hands-cultnet-contracts.md index 0a2ff2e3..ad107a2a 100644 --- a/notes/hands-cultnet-contracts.md +++ b/notes/hands-cultnet-contracts.md @@ -7,7 +7,7 @@ and leave receipts that can be verified, refused, or admitted into Mind state. ## Authority Map - Owner: Hands owns execution of bounded actions. -- Inputs: typed action intents, Body access grants, requested commands or +- Inputs: typed action intents, Substrate Gate access grants, requested commands or patches, current repo policy, Soul verification requirements, and coordinator authority. - Outputs: Hands action reviews, command receipts, patch receipts, commit @@ -20,7 +20,7 @@ and leave receipts that can be verified, refused, or admitted into Mind state. access. - Shared path: file edits, shell commands, commits, PRs, and rollbacks should share Hands action intent/review/receipt semantics. -- Deletion line: Body grants access; it does not execute. Soul verifies; it +- Deletion line: Substrate Gate grants access; it does not execute. Soul verifies; it does not execute. Mind records durable state; it does not execute. ## Contract Families @@ -36,7 +36,7 @@ and leave receipts that can be verified, refused, or admitted into Mind state. ## Neighboring Gates -Body grants substrate access before Hands touches the repo. Eyes packages +Substrate Gate grants substrate access before Hands touches the repo. Eyes packages evidence for action reasoning. Soul verifies action results and invariants. Mind admits durable state after the action and verification receipts exist. diff --git a/notes/life-cultnet-contracts.md b/notes/life-cultnet-contracts.md index ebf03f6a..5b2464cc 100644 --- a/notes/life-cultnet-contracts.md +++ b/notes/life-cultnet-contracts.md @@ -37,6 +37,6 @@ scratch notes or hopeful transcript memory. Life preserves what survives rupture. Mind decides what preserved material becomes durable state. Soul verifies continuity invariants. Self routes recovery -work. Body and Eyes regather reality when continuity is missing. +work. Eyes and Proprioception regather reality when continuity is missing. Life is not nostalgia. It is survival with receipts. diff --git a/notes/mind-cultnet-contracts.md b/notes/mind-cultnet-contracts.md index 680cf311..58151246 100644 --- a/notes/mind-cultnet-contracts.md +++ b/notes/mind-cultnet-contracts.md @@ -4,13 +4,13 @@ Objective: make Mind the persistent state guardian. The state is the Mind; every sub-agent output is a thought or proposal until Mind admits it into durable state. -Body is the neighboring gate. Body decides whether an organ may touch the repo; +Body is the neighboring gate. Substrate Gate decides whether an organ may touch the repo; Mind decides whether the resulting thought, evidence, or proposal mutates persistent state. Do not collapse these into one throne. That is how the machine starts lying with excellent posture. Imagination is the neighboring Projector for Face. It may compose a lived scene -from state, Body facts, social pressure, and organ dependencies, but it does not +from state, Body substrate facts, social pressure, and organ dependencies, but it does not interpret side effects or admit state. ## Authority Map diff --git a/notes/organ-dependency-contracts.md b/notes/organ-dependency-contracts.md index 316d06ef..6a827da0 100644 --- a/notes/organ-dependency-contracts.md +++ b/notes/organ-dependency-contracts.md @@ -11,7 +11,8 @@ pressure of the others before acting. - `imagination`: projection, possible worlds, plans, and narrative scene construction. - `eyes`: evidence seeking and source inspection. -- `body`: repository/substrate access and anatomy. +- `proprioception`: internal model of Body shape, architecture, dataflow, and + checkpoint anatomy. - `hands`: edits, commands, and external action. - `soul`: verification, ethics, invariants, and falsification. - `life`: continuity, compaction, sleep, handoff, and recovery. @@ -23,35 +24,36 @@ For every standing organ `X`, `X.dependsOn` is every other standing organ. 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 facts, Mind-reviewed memory, Soul constraints, Life +- Face speaks with Body substrate facts, Mind-reviewed memory, Soul constraints, Life continuity, Self routing pressure, Eyes uncertainty, Hands consequence, and Imagination scene. -- Hands acts only after Body grants substrate access, Eyes supplies enough +- Hands acts only after Substrate Gate grants substrate access, Eyes supplies enough evidence, Soul keeps the invariant visible, Self routes authority, Life 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 which other organs shaped the proposal. -- Eyes supplies source-grounded evidence packets after Body grants access, so +- Eyes supplies source-grounded evidence packets after Substrate Gate grants access, so the other organs do not mistake raw retrieval for inspected truth. ## Projector Ownership -The Projector is Imagination acting for Face. It turns typed state, Body facts, +The Projector is Imagination acting for Face. It turns typed state, Body substrate facts, social pressure, memory, and organ dependencies into a lived scene. It does not speak publicly, grant repo access, or admit state. The Face loop is: ```text -Body-gated facts + Mind state + social stimulus + organ dependencies +Substrate-Gate-scoped facts + Mind state + social stimulus + organ dependencies -> Imagination Projector -> Face natural turn -> Mind Interpreter -> reviewed state effects / side effects / silence ``` -Mind is the Interpreter and persistent state guardian. Body is the repository -access guardian. Eyes is the evidence ingress guardian. Imagination is the -Projector. Face is the public person. The dependency web is how the machine -avoids lonely little monarchies in costumes. +Mind is the Interpreter and persistent state guardian. Substrate Gate is the +repository access protocol. Eyes is the evidence ingress guardian. +Proprioception is the internal model of the Body. Imagination is the Projector. +Face is the public person. The dependency web is how the machine avoids lonely +little monarchies in costumes. diff --git a/notes/perfect-machine-audit-roadmap.md b/notes/perfect-machine-audit-roadmap.md index f9e0be23..293b3a6c 100644 --- a/notes/perfect-machine-audit-roadmap.md +++ b/notes/perfect-machine-audit-roadmap.md @@ -14,7 +14,7 @@ Epiphany has the first typed skeleton for the organ boundaries: - `Mind`: persistent state guardian. `epiphany-core::mind_gateway` names thought, state-effect proposal, gateway-review, commit/rejection, and Verse adoption contracts. -- `Body`: repository/substrate access guardian. `epiphany-core::body_gateway` +- `Substrate Gate`: repository/substrate access protocol. `epiphany-core::substrate_gate` names repo access requests, reviews, grant/refusal receipts, snapshots, and mutation receipts. - `Eyes`: evidence ingress guardian. `epiphany-core::eyes_gateway` names @@ -25,7 +25,7 @@ Epiphany has the first typed skeleton for the organ boundaries: - `Face`: public person-shaped surface. It receives projected context and writes natural prose only. - `Hands`: action organ by doctrine, but not yet backed by a dedicated CultNet - contract family parallel to Body/Eyes/Mind. + 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 @@ -82,7 +82,7 @@ as Void's `rejectLeakyMemorySurface`. ### 1. Contract Names Exist Before Contract Execution -Mind, Body, and Eyes have type constants, CultMesh policy documents, and +Mind, Substrate Gate, and Eyes have type constants, CultMesh policy documents, and runtime-spine advertisement. They are not yet the mandatory runtime path. Workers can still be launched and accepted through older bridge/service flows without every substrate touch, evidence claim, or state mutation passing through @@ -90,14 +90,14 @@ a real receipt chain. Required correction: turn contract families into executable gates. -### 2. Body/Eyes/Mind Are Correctly Split But Not Yet Chained +### 2. Substrate Gate/Eyes/Mind Are Correctly Split But Not Yet Chained The desired chain is: ```text Need fact or action -> Self routes - -> Body grants scoped substrate access + -> Substrate Gate grants scoped substrate access -> Eyes packages inspected evidence when truth is needed -> Imagination projects options or scenes when future/personhood is needed -> Hands executes bounded action when mutation is needed @@ -124,7 +124,7 @@ 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, Body, +carries the full standing organ dependency matrix plus required Mind, Substrate Gate, Eyes, Hands, Soul, and Life 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 @@ -198,7 +198,7 @@ repo-contained dependency body. - Ran the previously blocked focused surface through: - `cargo test --manifest-path .\epiphany-core\Cargo.toml --lib face_turn` - `cargo test --manifest-path .\epiphany-core\Cargo.toml --lib mind_gateway` - - `cargo test --manifest-path .\epiphany-core\Cargo.toml --lib body_gateway` + - `cargo test --manifest-path .\epiphany-core\Cargo.toml --lib substrate_gate` - `cargo test --manifest-path .\epiphany-core\Cargo.toml --lib eyes_gateway` - `cargo test --manifest-path .\epiphany-core\Cargo.toml --lib cultmesh_integration` - `cargo test --manifest-path .\epiphany-core\Cargo.toml --lib runtime_spine::tests::runtime_spine_emits_cultnet_hello_frame` @@ -213,9 +213,9 @@ without local path superstition. Verification: `cargo test --manifest-path Goal: no worker output, repo touch, or evidence claim bypasses the appropriate organ. -- Implement Body access request/review/grant/refusal documents in CultCache. +- Implement Substrate Gate access request/review/grant/refusal documents in CultCache. - Route retrieval, indexing, file edit, shell command, Rider, and Unity bridge - operations through Body access receipts. + operations through Substrate Gate access receipts. - Implement Eyes evidence request/review/packet/refusal documents in CultCache. - Require Eyes packets for claims promoted into Mind state proposals when the claim depends on inspected source. @@ -252,7 +252,7 @@ Status: first contract catalog slice landed. - `epiphany.life.stale_turn_repair` Definition of done: action, verification, and continuity have the same typed -contract dignity as Mind/Body/Eyes, and every worker launch carries the +contract dignity as Mind/Substrate Gate/Eyes, and every worker launch carries the organ-dependency/receipt contract that later gates can enforce. Verification: `cargo test --manifest-path .\epiphany-core\Cargo.toml --lib` and `cargo run --manifest-path .\epiphany-core\Cargo.toml --bin epiphany-cultmesh-smoke` pass @@ -277,7 +277,7 @@ Goal: Face becomes a living public organ without stealing authority. - human pronoun guidance - channel label/permission policy - media attachment awareness - - recent home-repo activity from Body-gated reads + - recent home-repo activity from Substrate-Gate-scoped reads - Make projection model-owned and read-only, with model output receipts. - Strengthen projection leakage rejection: no schema words, repo paths, prompt construction language, grants/jurisdictions slurry, or direct action syntax. @@ -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 Body/Eyes/Hands/Soul/Life/Mind receipts. + dependency matrix, and required Substrate Gate/Eyes/Hands/Soul/Life/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 Body/Eyes/Hands/Soul/Life +- Next: make acceptance refuse results missing required Substrate Gate/Eyes/Hands/Soul/Life 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 @@ -342,7 +342,7 @@ 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 Body grants, Eyes packets, Hands actions, Soul verdicts, Life +- Display Substrate Gate grants, Eyes packets, Hands actions, Soul verdicts, Life continuity, and Mind state commits. Definition of done: a human can ask "why did you touch that file / say that / @@ -355,7 +355,7 @@ coherent authority graph: ```text Self routes. -Body grants substrate access. +Substrate Gate grants substrate access. Eyes certifies looked-at evidence. Imagination projects possible scenes and futures. Face speaks as a person. diff --git a/notes/repo-personality-projection-layer-plan.md b/notes/repo-personality-projection-layer-plan.md index 362d9726..76342058 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, Body, Hands, Soul, and Life. +Imagination, Eyes, Proprioception, Hands, Soul, and Life. ## Source Families @@ -288,7 +288,7 @@ Projection: - Determines how aggressively Eyes must research existing systems, official docs, live runtime state, and repo-local source before invention. -### Body +### Proprioception Primary inputs: @@ -316,7 +316,7 @@ Primary inputs: Projection: - Determines slice size, willingness to edit, need for queue state, and how much - Hands must wait for Body/Soul before cutting. + Hands must wait for Proprioception/Soul before cutting. ### Soul @@ -482,7 +482,7 @@ the machine has repeatable bones. - Do not store repo facts inside role personality memory. - Do not let high aesthetic appetite lower verification gates. - Do not let high experimental heat excuse churn without receipts. -- Do not let high production pressure make Hands bypass Body or Soul. +- Do not let high production pressure make Hands bypass Proprioception or Soul. - Treat low-confidence inferred personality as a candidate, not a soul brand. ## Landed First Slice @@ -527,7 +527,7 @@ personality initialization record. After Self accepts the initial role-memory pressure, personality is allowed to drift through heartbeat, mood, rumination, sleep consolidation, lived evidence, and reviewed `selfPatch` mutations. Startup must not rerun this specialist merely because terrain changed or the repo -reopened; major terrain surprises should route to Eyes/Body/Self as normal +reopened; major terrain surprises should route to Eyes/Proprioception/Self as normal modeling or review work, not as a personality reset. ## Repo Memory Distillation @@ -546,7 +546,7 @@ distiller brief for each standing organ: - Face receives public-surface, Aquarium, Discord, voice, and sealed-thought boundary memory. - Imagination receives roadmap, backlog, objective-shaping, dream, and rejected-path memory. - Eyes receives research, prior-art, canonical algorithm, vendor/API, and invention-avoidance memory. -- Body receives architecture, graph, control/data-flow, invariant, and checkpoint memory. +- 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. diff --git a/notes/substrate-gate-cultnet-contracts.md b/notes/substrate-gate-cultnet-contracts.md new file mode 100644 index 00000000..7c482f61 --- /dev/null +++ b/notes/substrate-gate-cultnet-contracts.md @@ -0,0 +1,61 @@ +# Substrate Gate CultNet Contracts + +Objective: make the Substrate Gate the repository access protocol. Body is the +substrate itself, not a gatekeeper persona and not the modeling organ. Organs +may request reads, indexing, commands, edits, and bridge operations, but the +Substrate Gate decides the scoped access to the repo. + +## Authority Map + +- Owner: the Substrate Gate protocol owns repository access grants and refusals. +- Inputs: typed repo access requests, workspace identity, requested paths, + requested operations, command/bridge intent, current repo policy, coordinator + authority, operator approvals, and relevant safety/evidence context. +- Outputs: Substrate Gate access reviews, access grant receipts, access refusal + receipts, repo snapshot receipts, and repo mutation receipts. +- Derived state: retrieved snippets, search hits, index manifests, diffs, build + logs, Unity/Rider bridge artifacts, and source maps are evidence projections, + not permission to touch more substrate. +- Forbidden writers/readers: Hands, Eyes, Face, public Verse ingress, raw worker + launches, compatibility JSON-RPC routes, and bridge tools must not directly + read, index, execute against, or mutate the repo without a scoped Substrate + Gate grant. +- Shared path: source reads, semantic indexing, file edits, command execution, + and editor/runtime bridge operations should all be expressible as + Substrate-Gate-scoped repo access requests with receipts. +- Deletion line: worker launch `authority_scope` is not repo access authority. + It may describe role/task scope, but the Substrate Gate must grant substrate + access. + +## Contract Families + +- `epiphany.substrate_gate.repo_access_request`: request for scoped repository + access. +- `epiphany.substrate_gate.repo_access_review`: Substrate Gate decision and scope + explanation. +- `epiphany.substrate_gate.repo_access_grant_receipt`: proof of scoped access. +- `epiphany.substrate_gate.repo_access_refusal_receipt`: proof of refusal. +- `epiphany.substrate_gate.repo_snapshot_receipt`: proof of source + inspection/indexing performed under Substrate Gate access. +- `epiphany.substrate_gate.repo_mutation_receipt`: proof that mutation or + repo-affecting command execution had a prior Substrate Gate grant. + +## Verse Boundary + +Substrate Gate access contracts live in `epiphany-internal`. Operator-safe +projections may appear in `gamecult-local` after review, but raw repo access +requests, private paths, command cargo, diffs, and mutation receipts stay +internal unless another explicit export policy says otherwise. +`epiphany-global` never gains repository access authority. + +Mind and the Substrate Gate are neighboring protocols, not aliases. The +Substrate Gate decides whether the machine may touch the repo. Mind decides +whether resulting thought or evidence mutates persistent state. + +Imagination can project Body substrate facts into a Face scene only after those facts have +entered through Substrate-Gate-scoped access. A beautiful scene is not a repo +access grant. Eyes is the next gate after access: a Substrate Gate grant allows +looking, but only Eyes can turn looked-at material into a citable evidence +packet. Proprioception may update the machine's internal body model only from +source-grounded material that has passed through the appropriate access and +evidence path. diff --git a/notes/true-epiphany-memory-migration-sandbox-prompt.md b/notes/true-epiphany-memory-migration-sandbox-prompt.md index 6491b75e..a2c6f4cf 100644 --- a/notes/true-epiphany-memory-migration-sandbox-prompt.md +++ b/notes/true-epiphany-memory-migration-sandbox-prompt.md @@ -15,7 +15,7 @@ Convert useful doctrine, durable lessons, and repo-local planning/modeling surfa - Face / public surface - Imagination / planning and future shape - Eyes / research and existing-work scout -- Body / modeling, graph, checkpoint, source anatomy +- Proprioception / modeling, graph, checkpoint, source anatomy - Hands / implementation actuator - Soul / verification, evidence, objective truth - Life / continuity, CRRC, compaction, reorientation @@ -164,7 +164,7 @@ Good memories for Eyes sound like: - "Semantic retrieval is an orientation tool; exact patch work still needs exact source reads." - "Known libraries, vendor behavior, and official examples should beat homemade machinery unless local constraints prove otherwise." -### Body / Modeling +### Proprioception / Modeling Look for lessons about architecture maps, data flow, graph shape, domain seams, typed contracts, source anatomy, and checkpoint readiness. @@ -177,7 +177,7 @@ Likely sources: - LunaMosaic's scene graph / region contract / manifest direction. - VoidBot's split runtime organs. -Good memories for Body sound like: +Good memories for Proprioception sound like: - "A model is ready when it names ownership boundaries, inputs, outputs, invariants, and acceptance evidence." - "Do not centralize app-domain state merely because a shared mechanism touches it." @@ -397,7 +397,7 @@ Write these files: - which repo roadmaps became roadmap streams - which backlog items and objective drafts are low-confidence or stale - which source maps were strong enough to become graph/model candidates - - what should be reviewed by Imagination, Body, Soul, or the human before apply + - what should be reviewed by Imagination, Proprioception, Soul, or the human before apply 4. `role-selfpatches/` @@ -416,13 +416,13 @@ Write these files: ```json { - "agentId": "epiphany.body", - "reason": "Distilled adjacent pseudo-Epiphany modeling doctrine into Body's future graph/checkpoint judgment.", + "agentId": "epiphany.proprioception", + "reason": "Distilled adjacent pseudo-Epiphany modeling doctrine into Proprioception's future graph/checkpoint judgment.", "evidenceIds": ["pseudo-repo-memory-migration-2026-05-05"], "semanticMemories": [ { "memoryId": "mem-body-source-owned-boundaries", - "summary": "Shared mechanisms do not own app-domain truth; Body should model provider/auth/runtime seams by naming ownership, inputs, outputs, invariants, and acceptance evidence before Hands edits.", + "summary": "Shared mechanisms do not own app-domain truth; Proprioception should model provider/auth/runtime seams by naming ownership, inputs, outputs, invariants, and acceptance evidence before Hands edits.", "salience": 0.88, "confidence": 0.84 } diff --git a/schemas/canonical-agent-state-schema.md b/schemas/canonical-agent-state-schema.md index bb4740bd..01ec0935 100644 --- a/schemas/canonical-agent-state-schema.md +++ b/schemas/canonical-agent-state-schema.md @@ -35,7 +35,7 @@ Each record in `state/agents.msgpack` is an - `face` -> `epiphany.face` - `imagination` -> `epiphany.imagination` - `research` -> `epiphany.eyes` -- `modeling` -> `epiphany.body` +- `modeling` -> `epiphany.proprioception` - `implementation` -> `epiphany.hands` - `verification` -> `epiphany.soul` - `reorientation` -> `epiphany.life` diff --git a/state/ledgers.msgpack b/state/ledgers.msgpack index dad70b7b..c6c5c1ae 100644 Binary files a/state/ledgers.msgpack and b/state/ledgers.msgpack differ diff --git a/state/map.yaml b/state/map.yaml index 65c35de9..6072b028 100644 --- a/state/map.yaml +++ b/state/map.yaml @@ -83,13 +83,13 @@ active_subgoals: - Grow the VoidBot repo-Face pattern into Epiphany's product direction: each Epiphany owns one or more repos, has one or more Faces, and exposes project-native conversation through Aquarium, Discord, voice/WebRTC, stream surfaces, CLI, and CultNet clients so humans can talk to projects instead of pre-authoring complete implementation briefs. Face is special because Imagination acts as Projector, turning typed state into narrative context before the Face thinks, and Mind acts as Interpreter, turning natural Face output into reviewed state/side-effect intents after the Face thinks. - Make Mind the gateway between thought and state. The state is the Mind: sub-agent outputs are worker thoughts, not authority. Role/reorient findings, statePatch, selfPatch, observations, evidence, receipts, scratch, and checkpoints must route through Mind review before durable state changes, using the VoidBot Face Interpreter pattern as the starting membrane. - Use `notes/mind-cultnet-contracts.md` as the authority map for Mind's CultNet contract surface. CultMesh Verse placement is part of the contract: `epiphany-internal` carries private thought/proposal/review/commit/rejection flow, `gamecult-local` carries trusted operator-safe sharing without private-state authority, and `epiphany-global` carries public thought weather plus adoption receipts only. - - Use `notes/body-cultnet-contracts.md` as the authority map for Body's CultNet contract surface. Body is the repository access guardian: source reads, indexing, edits, commands, and editor/runtime bridge operations need scoped Body access receipts before Hands, Eyes, Face, workers, or bridge tools touch the repo. Mind and Body are separate gates: Body governs substrate access; Mind governs durable state admission. - - Use `notes/eyes-cultnet-contracts.md` as the authority map for Eyes' CultNet contract surface. Eyes is the evidence ingress guardian: Body 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 Body grants substrate access and before Soul verification/Mind admission. + - Use `notes/substrate-gate-cultnet-contracts.md` as the authority map for Substrate Gate CultNet contract surface. Substrate Gate is the repository access protocol: source reads, indexing, edits, commands, and editor/runtime bridge operations need scoped Substrate Gate access receipts before Hands, Eyes, Face, workers, or bridge tools touch the repo. Mind and Substrate Gate are separate gates: Substrate Gate governs substrate access; Mind governs durable state admission. + - 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. - 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, Body, Hands, Soul, and Life. Dependency does not collapse ownership; it makes each turn aware of the whole organism while Body still gates repo access and Mind still gates durable state. + - 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. - 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. @@ -110,10 +110,10 @@ accepted_design: - Distributed Epiphany dreaming is a CultMesh typed-document problem, not prompt folklore. CultCache owns local typed documents, Epiphany owns export/import/adoption policy, CultNet owns wire/provenance/shard delivery, and CultMesh owns Verses, peer exchange, leases, shard logs, replicas, and watchable runtime surfaces. Start with local dream document types and a local store before public Verse wiring. - The first Rust CultMesh integration slice is landed and repaired to compile from repo-contained vendored crates. `vendor/cultmesh-rs` is a small Rust node/database facade over vendored CultCache and CultNet with document-set registration and durable typed put/get/delete. `vendor/cultcache-rs` now reads and writes the `cultcache.store.v1` snapshot format used by `state/ledgers.msgpack`, so `epiphany-state status` is a working re-entry rite again. `epiphany-core` depends on `vendor/cultcache-rs`, `vendor/cultnet-rs`, and `vendor/cultmesh-rs`, exposes an `EpiphanyCultMeshStatusEntry`, records typed `EpiphanyCultMeshVersePolicyEntry` documents for the internal/local-area/global Verse tiers, and records typed `EpiphanyCultMeshGlobalRoomPolicyEntry` documents for threaded public global rooms such as dreams, architecture, research, faces, GameCult, and governance. Native operator status is now a typed `EpiphanyCultMeshOperatorStatusEntry` in the internal Verse; it names Codex as bridge transport, Epiphany as authority owner, prompt-authority separation, and the quarantined Rider/Unity optional surfaces. Native operator snapshots are typed `EpiphanyCultMeshOperatorSnapshotEntry` documents distilled from operator-safe status artifacts; local status runs now write `.epiphany-run/cultmesh/operator-snapshots.ccmp` instead of leaving JSON artifacts as the only operator memory. - 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. - - Body's repo-access contract surface is now named beside Mind's state gate: `epiphany-core::body_gateway` defines repo access requests, access reviews, grant/refusal receipts, snapshot receipts, and mutation receipts; runtime-spine advertises those contracts; CultMesh persists matching `EpiphanyCultMeshBodyContractEntry` 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 Body 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/Body/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/Body/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. + - 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. - `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, Body, 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 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 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/Body, 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 the Body of 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, Body 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, Body, 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/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`. - `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,7 +260,7 @@ 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, Body, 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, 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 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. diff --git a/state/scratch-compaction-17cd64d8-da88-4642-a871-4cf1b768c20a.md b/state/scratch-compaction-17cd64d8-da88-4642-a871-4cf1b768c20a.md index fee9e78b..c05e79bf 100644 --- a/state/scratch-compaction-17cd64d8-da88-4642-a871-4cf1b768c20a.md +++ b/state/scratch-compaction-17cd64d8-da88-4642-a871-4cf1b768c20a.md @@ -27,7 +27,7 @@ What was done: - Read/sampled each primary repo's AGENTS/map/evidence/handoff/scratch where present and secondary AGENTS files. - Inspected EpiphanyAgent's Ghostlight role memory schema and patch validator: - state/agents/README.md - - state/agents/body.agent-state.json + - state/agents/proprioception.agent-state.json - native epiphany-agent-memory-store binary - Added new documentation file: - notes/true-epiphany-memory-migration-sandbox-prompt.md @@ -36,7 +36,7 @@ Important content of the new prompt: - It is a self-contained sandbox-agent prompt. - It instructs the sandbox agent to produce reviewable migration artifacts under `.epiphany-imports/pseudo-repo-memory-migration-`. - It explicitly forbids direct mutation by default. -- It maps adjacent repo lessons into role-specific memory targets for Self, Face, Imagination, Eyes, Body, Hands, Soul, and Life. +- It maps adjacent repo lessons into role-specific memory targets for Self, Face, Imagination, Eyes, Proprioception, Hands, Soul, and Life. - It requires source-inventory.json, distillation-report.md, role-selfpatches/*.json, review-results.json, and apply-plan.md. - It requires each proposed memory patch to validate via native epiphany-agent-memory-store review-patch. - It emphasizes project truth versus role memory separation.