From d04cde2c5e3ecbc4ed198d5aa9746280d2e39079 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Fri, 29 May 2026 01:23:43 +0100 Subject: [PATCH] Split organ state from Persona state --- epiphany-core/src/agent_launch.rs | 2 +- epiphany-core/src/agent_memory.rs | 68 +-- epiphany-core/src/agent_utterance_state.rs | 14 +- .../src/bin/epiphany-character-loop.rs | 16 +- epiphany-core/src/cultmesh_integration.rs | 12 +- epiphany-core/src/eyes_gateway.rs | 2 +- epiphany-core/src/lib.rs | 20 +- .../src/memory_graph/profiles/agent.rs | 4 +- .../src/prompts/epiphany_specialists.toml | 16 +- notes/epiphany-anatomy.md | 9 +- notes/fresh-workspace-handoff.md | 32 +- notes/voidbot-routine-adoption-plan.md | 36 +- schemas/README.md | 23 +- schemas/agent-state-variable-glossary.md | 29 +- schemas/agent-utterance-state-schema.md | 12 +- schemas/canonical-agent-state-schema.md | 85 ++-- schemas/cultnet/README.md | 4 +- ...epiphany.agent-utterance-state.schema.json | 22 +- .../cultnet/epiphany.agent.memory.schema.json | 2 +- .../epiphany.work_organ_state.v0.schema.json | 196 +++++++++ .../gamecult.persona_state.v0.schema.json | 415 ++++++++++++++++++ schemas/cultnet/index.json | 22 + schemas/dossier-profiles.md | 112 ----- schemas/ghostlight.agent-state.schema.json | 2 +- schemas/heartbeat-state-schema.md | 6 +- schemas/organ-state-profiles.md | 120 +++++ schemas/repo-personality-birth-projection.md | 2 +- state/agents.msgpack | Bin 22337 -> 17119 bytes state/ledgers.msgpack | Bin 165840 -> 166638 bytes state/map.yaml | 35 +- 30 files changed, 996 insertions(+), 322 deletions(-) create mode 100644 schemas/cultnet/epiphany.work_organ_state.v0.schema.json create mode 100644 schemas/cultnet/gamecult.persona_state.v0.schema.json delete mode 100644 schemas/dossier-profiles.md create mode 100644 schemas/organ-state-profiles.md diff --git a/epiphany-core/src/agent_launch.rs b/epiphany-core/src/agent_launch.rs index ccdda126..3c40f989 100644 --- a/epiphany-core/src/agent_launch.rs +++ b/epiphany-core/src/agent_launch.rs @@ -123,7 +123,7 @@ pub fn epiphany_role_launch_output_schema(role_id: EpiphanyRoleResultRoleId) -> }, "selfPatch": { "type": "object", - "description": "Optional bounded request to update this role's Ghostlight-shaped persistent memory file. This is for lane habits, durable lessons, personality pressure, goals, or values only. It must not contain project truth, code edits, job authority, graph/frontier/checkpoint/planning changes, or objective changes.", + "description": "Optional bounded request to update this role's persistent organ memory. Work organs may update lane habits, durable lessons, goals, values, or private notes; Persona affect/social state belongs only to Face-style Persona surfaces. It must not contain project truth, code edits, job authority, graph/frontier/checkpoint/planning changes, or objective changes.", "required": ["agentId", "reason"], "properties": { "agentId": { diff --git a/epiphany-core/src/agent_memory.rs b/epiphany-core/src/agent_memory.rs index ff6a680d..fc844134 100644 --- a/epiphany-core/src/agent_memory.rs +++ b/epiphany-core/src/agent_memory.rs @@ -303,17 +303,19 @@ pub struct AgentMemoryReview { #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] -pub enum EpiphanyDossierProfileKind { - LaneCore, - EmbodiedActor, +pub enum EpiphanyOrganStateProfileKind { + WorkOrgan, + Persona, } #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] -pub struct EpiphanyDossierProfile { - pub profile_kind: EpiphanyDossierProfileKind, - pub canonical_density: String, +pub struct EpiphanyOrganStateProfile { + pub profile_kind: EpiphanyOrganStateProfileKind, + pub state_density: String, + pub portable_contract: String, pub relationship_model: String, + pub affect_model: String, pub perceived_overlay_mode: String, pub growth_channels: Vec, pub notes: Vec, @@ -686,7 +688,7 @@ pub fn agent_memory_status(store_path: impl AsRef) -> Result { "roleId": role_id, "agentId": entry.agent.agent_id, "displayName": entry.agent.identity.name, - "dossierProfile": dossier_profile_for_role(role_id), + "organStateProfile": organ_state_profile_for_role(role_id), "semanticMemories": entry.agent.memories.semantic.len(), "episodicMemories": entry.agent.memories.episodic.len(), "relationshipMemories": entry.agent.memories.relationship_summaries.len(), @@ -711,38 +713,43 @@ pub fn agent_memory_status(store_path: impl AsRef) -> Result { })) } -pub fn dossier_profile_for_role(role_id: &str) -> EpiphanyDossierProfile { +pub fn organ_state_profile_for_role(role_id: &str) -> EpiphanyOrganStateProfile { match role_id { - "face" => EpiphanyDossierProfile { - profile_kind: EpiphanyDossierProfileKind::EmbodiedActor, - canonical_density: "dense_ghostlight_core_preferred".to_string(), + "face" => EpiphanyOrganStateProfile { + profile_kind: EpiphanyOrganStateProfileKind::Persona, + state_density: "persona_grade".to_string(), + portable_contract: "gamecult.persona_state.v0".to_string(), relationship_model: "relationship_summaries_and_directional_stance_matter".to_string(), + affect_model: "persona_affect_allowed_and_expected".to_string(), perceived_overlay_mode: "observer_local_and_fallible".to_string(), growth_channels: vec![ "heartbeat appraisal and reaction".to_string(), "character-loop interpretation".to_string(), + "persona affect and social-read interpretation".to_string(), "episodic and relationship memory accumulation".to_string(), "reviewed selfPatch".to_string(), "sleep/distillation".to_string(), ], notes: vec![ - "Face should behave like an embodied, responsive, and fallible public creature rather than a thin tool wrapper.".to_string(), - "Dense Ghostlight-style canonical families, perceived overlays, and relationship pressure are appropriate here.".to_string(), + "Epiphany Face is an organ; Persona is the portable person-state contract shared with Ghostlight and VoidBot-style repo Faces.".to_string(), + "Dense canonical families, affect, perceived overlays, and relationship pressure are appropriate for Persona state.".to_string(), ], }, - _ => EpiphanyDossierProfile { - profile_kind: EpiphanyDossierProfileKind::LaneCore, - canonical_density: "lean_role_lattice".to_string(), + _ => EpiphanyOrganStateProfile { + profile_kind: EpiphanyOrganStateProfileKind::WorkOrgan, + state_density: "lean_work_organ".to_string(), + portable_contract: "epiphany.work_organ_state.v0".to_string(), relationship_model: "role_local_summary_only".to_string(), + affect_model: "no_affect_or_persona_machinery".to_string(), perceived_overlay_mode: "minimal_until_a_real_need_exists".to_string(), growth_channels: vec![ "reviewed selfPatch".to_string(), "heartbeat rumination pressure".to_string(), "sleep/distillation".to_string(), - "birth-time repo personality and memory seeding".to_string(), + "birth-time repo memory and light operating-pressure seeding".to_string(), ], notes: vec![ - "Most standing Epiphany organs need sharp role identity, room to grow, and resistance to personality sludge more than they need full dramatic embodiment.".to_string(), + "Work organs need sharp role identity, durable mission memory, values/goals, and heartbeat activation; they do not need Face affect or full Persona machinery.".to_string(), "Sparse canonical bundles are acceptable here as long as memory, goals, values, and private notes can deepen over time.".to_string(), ], }, @@ -932,6 +939,7 @@ fn validate_agent_entry(entry: &EpiphanyAgentMemoryEntry, expected_agent_id: &st for (index, value) in entry.agent.canonical_state.values.iter().enumerate() { validate_value(value, &format!("values[{index}]"), &mut errors); } + let profile = organ_state_profile_for_role(&entry.role_id); for (group_name, group) in [ ( "underlying_organization", @@ -955,7 +963,7 @@ fn validate_agent_entry(entry: &EpiphanyAgentMemoryEntry, expected_agent_id: &st &entry.agent.canonical_state.situational_state, ), ] { - if group.is_empty() { + if group.is_empty() && profile.profile_kind == EpiphanyOrganStateProfileKind::Persona { errors.push(format!("canonical_state.{group_name} must not be empty")); } for (name, vector) in group { @@ -1456,7 +1464,7 @@ mod tests { "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.", + "summary": "Native role memory patches update typed CultCache organ state rather than JSON dossier files.", "salience": 0.74, "confidence": 0.86 }] @@ -1532,14 +1540,18 @@ mod tests { } #[test] - fn dossier_profiles_distinguish_face_from_lane_organs() { - let face = dossier_profile_for_role("face"); - assert_eq!(face.profile_kind, EpiphanyDossierProfileKind::EmbodiedActor); - assert_eq!(face.canonical_density, "dense_ghostlight_core_preferred"); + fn organ_state_profiles_distinguish_face_from_lane_organs() { + let face = organ_state_profile_for_role("face"); + assert_eq!(face.profile_kind, EpiphanyOrganStateProfileKind::Persona); + assert_eq!(face.state_density, "persona_grade"); + assert_eq!(face.portable_contract, "gamecult.persona_state.v0"); + assert_eq!(face.affect_model, "persona_affect_allowed_and_expected"); - let hands = dossier_profile_for_role("implementation"); - assert_eq!(hands.profile_kind, EpiphanyDossierProfileKind::LaneCore); - assert_eq!(hands.canonical_density, "lean_role_lattice"); + let hands = organ_state_profile_for_role("implementation"); + assert_eq!(hands.profile_kind, EpiphanyOrganStateProfileKind::WorkOrgan); + assert_eq!(hands.state_density, "lean_work_organ"); + assert_eq!(hands.portable_contract, "epiphany.work_organ_state.v0"); + assert_eq!(hands.affect_model, "no_affect_or_persona_machinery"); } fn sample_agent_json(agent_id: &str, name: &str) -> String { @@ -1549,7 +1561,7 @@ mod tests { "world_id": "epiphany-agent-memory", "setting": "Epiphany local harness role memory", "time": {"label": "standing memory"}, - "canon_context": ["Role dossiers preserve lane identity."] + "canon_context": ["Organ-state records preserve lane identity."] }, "agents": [{ "agent_id": agent_id, diff --git a/epiphany-core/src/agent_utterance_state.rs b/epiphany-core/src/agent_utterance_state.rs index f9ac7d70..2e1f914a 100644 --- a/epiphany-core/src/agent_utterance_state.rs +++ b/epiphany-core/src/agent_utterance_state.rs @@ -1,8 +1,8 @@ use crate::agent_memory::EpiphanyAgentMemoryEntry; -use crate::agent_memory::EpiphanyDossierProfile; +use crate::agent_memory::EpiphanyOrganStateProfile; use crate::agent_memory::GhostlightCanonicalState; use crate::agent_memory::GhostlightTraitVector; -use crate::agent_memory::dossier_profile_for_role; +use crate::agent_memory::organ_state_profile_for_role; use crate::heartbeat_state::HeartbeatParticipant; use serde::Deserialize; use serde::Serialize; @@ -19,7 +19,7 @@ pub struct AgentUtteranceState { pub source: String, pub role_id: String, pub agent_id: String, - pub dossier_profile: EpiphanyDossierProfile, + pub organ_state_profile: EpiphanyOrganStateProfile, pub identity: AgentUtteranceIdentity, pub personality_vectors: AgentUtterancePersonalityVectors, pub values: Vec, @@ -198,7 +198,7 @@ pub fn derive_agent_utterance_state( source: vector_source, role_id: entry.role_id.clone(), agent_id: entry.agent.agent_id.clone(), - dossier_profile: dossier_profile_for_role(&entry.role_id), + organ_state_profile: organ_state_profile_for_role(&entry.role_id), identity, personality_vectors, values, @@ -1188,7 +1188,7 @@ fn trait_weight(vector: &GhostlightTraitVector) -> f64 { #[cfg(test)] mod tests { use super::*; - use crate::agent_memory::EpiphanyDossierProfileKind; + use crate::agent_memory::EpiphanyOrganStateProfileKind; use crate::agent_memory::GhostlightAgent; use crate::agent_memory::GhostlightIdentity; use crate::agent_memory::GhostlightMemories; @@ -1308,8 +1308,8 @@ mod tests { AGENT_UTTERANCE_STATE_SCHEMA_VERSION ); assert_eq!( - utterance.dossier_profile.profile_kind, - EpiphanyDossierProfileKind::EmbodiedActor + utterance.organ_state_profile.profile_kind, + EpiphanyOrganStateProfileKind::Persona ); assert_eq!(utterance.identity.name, "Epiphany"); assert_eq!(utterance.current_mood.label, "sparkly-urgent"); diff --git a/epiphany-core/src/bin/epiphany-character-loop.rs b/epiphany-core/src/bin/epiphany-character-loop.rs index 6dc74703..99175de0 100644 --- a/epiphany-core/src/bin/epiphany-character-loop.rs +++ b/epiphany-core/src/bin/epiphany-character-loop.rs @@ -14,8 +14,8 @@ use epiphany_core::HeartbeatParticipant; use epiphany_core::HeartbeatParticipantLocalContext; use epiphany_core::HeartbeatPersonalityProjection; use epiphany_core::derive_agent_utterance_state; -use epiphany_core::dossier_profile_for_role; use epiphany_core::load_agent_memory_entry_for_role; +use epiphany_core::organ_state_profile_for_role; use serde::Serialize; use serde_json::Value; use std::collections::BTreeMap; @@ -129,7 +129,7 @@ fn character_turn_packet( status: &str, mood: &str, ) -> Value { - let dossier_profile = dossier_profile_for_role(&entry.role_id); + let organ_state_profile = organ_state_profile_for_role(&entry.role_id); let participant = character_loop_participant(entry, status); let utterance_state = derive_agent_utterance_state(entry, Some(&participant), Some(mood), source); @@ -145,7 +145,7 @@ fn character_turn_packet( "mode": mode, "roleId": entry.role_id, "agentId": entry.agent.agent_id, - "dossierProfile": dossier_profile, + "organStateProfile": organ_state_profile, "turnKind": "stimulus_response", "responseContract": "Respond from projected local state and visible stimulus; do not leak hidden agent streams or invent omniscient truth.", }, @@ -171,7 +171,7 @@ fn character_turn_packet( "time": entry.world.time.label, "canonContext": entry.world.canon_context, }, - "dossierProfile": dossier_profile_for_role(&entry.role_id), + "organStateProfile": organ_state_profile_for_role(&entry.role_id), "activeGoals": entry.agent.goals.iter().map(|goal| serde_json::json!({ "goalId": goal.goal_id, "description": goal.description, @@ -232,7 +232,7 @@ fn character_turn_packet( }, "guardrails": [ "Humans talk to Face; other organs expose internals through Aquarium and typed artifacts rather than becoming direct chats.", - "Use character-local projection: the actor receives its own dossier and visible stimulus, not omniscient hidden state.", + "Use character-local projection: the actor receives its own organ or Persona state and visible stimulus, not omniscient hidden state.", "Run both cognition lanes before choosing an output: analytic keeps the promise honest, associative keeps the living signal from going flat.", "Appraise the thought cluster through this role's personality before reacting; do not use a global mood knob as a substitute for participant-local appraisal.", "If speech or action would be noise, return silence plus bounded rumination or selfPatch.", @@ -782,8 +782,8 @@ fn run_smoke() -> Result { let ok = packet["schema_version"] == CHARACTER_TURN_SCHEMA_VERSION && packet["protocol"]["bundle"] == "epiphany.character_loop" && packet["protocol"]["roleId"] == "face" - && packet["protocol"]["dossierProfile"]["profileKind"] == "embodied_actor" - && packet["projectedLocalContext"]["dossierProfile"]["profileKind"] == "embodied_actor" + && packet["protocol"]["organStateProfile"]["profileKind"] == "persona" + && packet["projectedLocalContext"]["organStateProfile"]["profileKind"] == "persona" && packet["utteranceState"]["schemaVersion"] == "epiphany.agent_utterance_state.v0" && packet["utteranceState"]["identity"]["name"] == packet["projectedLocalContext"]["identity"]["name"] @@ -823,7 +823,7 @@ fn run_smoke() -> Result { "bundle": packet["protocol"]["bundle"], "roleId": packet["protocol"]["roleId"], "agentId": packet["protocol"]["agentId"], - "dossierProfile": packet["protocol"]["dossierProfile"]["profileKind"], + "organStateProfile": packet["protocol"]["organStateProfile"]["profileKind"], "projectionSchema": packet["projectionSeed"]["schema_version"], "appraisalSchema": packet["appraisalSeed"]["schema_version"], "reactionSchema": packet["reactionSeed"]["schema_version"], diff --git a/epiphany-core/src/cultmesh_integration.rs b/epiphany-core/src/cultmesh_integration.rs index 53df422f..eafcaa3f 100644 --- a/epiphany-core/src/cultmesh_integration.rs +++ b/epiphany-core/src/cultmesh_integration.rs @@ -1,6 +1,6 @@ +use crate::default_continuity_cultnet_contracts; use crate::default_eyes_cultnet_contracts; use crate::default_hands_cultnet_contracts; -use crate::default_continuity_cultnet_contracts; use crate::default_mind_cultnet_contracts; use crate::default_soul_cultnet_contracts; use crate::default_substrate_gate_cultnet_contracts; @@ -59,7 +59,8 @@ pub const EPIPHANY_CULTMESH_HANDS_CONTRACT_SCHEMA_VERSION: &str = pub const EPIPHANY_CULTMESH_SOUL_CONTRACT_TYPE: &str = "epiphany.cultmesh.soul_contract"; pub const EPIPHANY_CULTMESH_SOUL_CONTRACT_SCHEMA_VERSION: &str = "epiphany.cultmesh.soul_contract.v0"; -pub const EPIPHANY_CULTMESH_CONTINUITY_CONTRACT_TYPE: &str = "epiphany.cultmesh.continuity_contract"; +pub const EPIPHANY_CULTMESH_CONTINUITY_CONTRACT_TYPE: &str = + "epiphany.cultmesh.continuity_contract"; pub const EPIPHANY_CULTMESH_CONTINUITY_CONTRACT_SCHEMA_VERSION: &str = "epiphany.cultmesh.continuity_contract.v0"; pub const EPIPHANY_CULTMESH_INTERNAL_VERSE_ID: &str = "epiphany-internal"; @@ -726,7 +727,7 @@ pub fn epiphany_cultmesh_verse_policies() -> Vec= 5); let node = open_epiphany_cultmesh_node(&store, "epiphany-test")?; - let continuity = node - .get_required::("epiphany.continuity.review")?; + let continuity = node.get_required::( + "epiphany.continuity.review", + )?; assert_eq!(continuity.verse_id, EPIPHANY_CULTMESH_INTERNAL_VERSE_ID); assert_eq!(continuity.authority, "continuity"); diff --git a/epiphany-core/src/eyes_gateway.rs b/epiphany-core/src/eyes_gateway.rs index 7f076911..a27b681d 100644 --- a/epiphany-core/src/eyes_gateway.rs +++ b/epiphany-core/src/eyes_gateway.rs @@ -89,7 +89,7 @@ pub fn default_eyes_cultnet_contracts() -> Vec { intent_document_types: Vec::new(), receipt_document_types: Vec::new(), notes: vec![ - "Evidence packets carry provenance, uncertainty, and source refs for Imagination, Mind, Hands, Soul, Face, Self, Body, and Continuity protocols.".to_string(), + "Evidence packets carry provenance, uncertainty, and source refs for Imagination, Mind, Hands, Soul, Face, Self, Proprioception, and Continuity protocols.".to_string(), ], }, ] diff --git a/epiphany-core/src/lib.rs b/epiphany-core/src/lib.rs index e5bf28e9..bb5247a8 100644 --- a/epiphany-core/src/lib.rs +++ b/epiphany-core/src/lib.rs @@ -1,13 +1,13 @@ mod agent_launch; mod agent_memory; mod agent_utterance_state; +mod continuity_gateway; mod cultmesh_integration; mod distillation; mod eyes_gateway; mod face_turn; mod hands_gateway; mod heartbeat_state; -mod continuity_gateway; mod memory_graph; mod mind_gateway; mod organ_dependencies; @@ -56,8 +56,8 @@ pub use agent_memory::AgentCanonicalTraitSeed; pub use agent_memory::AgentMemoryReview; pub use agent_memory::AgentSelfPatch; pub use agent_memory::EpiphanyAgentMemoryEntry; -pub use agent_memory::EpiphanyDossierProfile; -pub use agent_memory::EpiphanyDossierProfileKind; +pub use agent_memory::EpiphanyOrganStateProfile; +pub use agent_memory::EpiphanyOrganStateProfileKind; pub use agent_memory::GhostlightEvent; pub use agent_memory::GhostlightMemory; pub use agent_memory::GhostlightPerceivedStateOverlay; @@ -69,9 +69,9 @@ pub use agent_memory::agent_memory_status; pub use agent_memory::apply_agent_canonical_trait_seeds; pub use agent_memory::apply_agent_self_patch; pub use agent_memory::apply_agent_self_patch_document; -pub use agent_memory::dossier_profile_for_role; pub use agent_memory::load_agent_memory_entry_for_role; pub use agent_memory::migrate_agent_memory_json_dir_to_cultcache; +pub use agent_memory::organ_state_profile_for_role; pub use agent_memory::project_agent_memory_to_json_dir; pub use agent_memory::review_agent_self_patch; pub use agent_memory::review_agent_self_patch_document; @@ -90,12 +90,15 @@ 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 continuity_gateway::*; 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_CONTINUITY_CONTRACT_SCHEMA_VERSION; +pub use cultmesh_integration::EPIPHANY_CULTMESH_CONTINUITY_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; @@ -106,8 +109,6 @@ pub use cultmesh_integration::EPIPHANY_CULTMESH_HANDS_CONTRACT_SCHEMA_VERSION; pub use cultmesh_integration::EPIPHANY_CULTMESH_HANDS_CONTRACT_TYPE; pub use cultmesh_integration::EPIPHANY_CULTMESH_INTERNAL_TIER; pub use cultmesh_integration::EPIPHANY_CULTMESH_INTERNAL_VERSE_ID; -pub use cultmesh_integration::EPIPHANY_CULTMESH_CONTINUITY_CONTRACT_SCHEMA_VERSION; -pub use cultmesh_integration::EPIPHANY_CULTMESH_CONTINUITY_CONTRACT_TYPE; pub use cultmesh_integration::EPIPHANY_CULTMESH_LOCAL_AREA_TIER; pub use cultmesh_integration::EPIPHANY_CULTMESH_LOCAL_AREA_VERSE_ID; pub use cultmesh_integration::EPIPHANY_CULTMESH_MIND_CONTRACT_SCHEMA_VERSION; @@ -133,11 +134,11 @@ pub use cultmesh_integration::EPIPHANY_CULTMESH_SUBSTRATE_GATE_CONTRACT_SCHEMA_V 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::EpiphanyCultMeshContinuityContractEntry; pub use cultmesh_integration::EpiphanyCultMeshDocuments; pub use cultmesh_integration::EpiphanyCultMeshEyesContractEntry; pub use cultmesh_integration::EpiphanyCultMeshGlobalRoomPolicyEntry; pub use cultmesh_integration::EpiphanyCultMeshHandsContractEntry; -pub use cultmesh_integration::EpiphanyCultMeshContinuityContractEntry; pub use cultmesh_integration::EpiphanyCultMeshMindContractEntry; pub use cultmesh_integration::EpiphanyCultMeshOperatorRunIntentEntry; pub use cultmesh_integration::EpiphanyCultMeshOperatorRunReceiptEntry; @@ -148,10 +149,10 @@ 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_continuity_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; -pub use cultmesh_integration::epiphany_cultmesh_continuity_contracts; pub use cultmesh_integration::epiphany_cultmesh_mind_contracts; pub use cultmesh_integration::epiphany_cultmesh_operator_snapshot_from_status_json; pub use cultmesh_integration::epiphany_cultmesh_soul_contracts; @@ -164,10 +165,10 @@ 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_continuity_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; -pub use cultmesh_integration::write_epiphany_cultmesh_continuity_contracts; pub use cultmesh_integration::write_epiphany_cultmesh_mind_contracts; pub use cultmesh_integration::write_epiphany_cultmesh_operator_run_intent; pub use cultmesh_integration::write_epiphany_cultmesh_operator_run_receipt; @@ -271,7 +272,6 @@ pub use heartbeat_state::validate_heartbeat_cognition; pub use heartbeat_state::validate_heartbeat_state; pub use heartbeat_state::write_heartbeat_cognition_entry; pub use heartbeat_state::write_heartbeat_state_entry; -pub use continuity_gateway::*; pub use memory_graph::EpiphanyMemoryEdgeKind; pub use memory_graph::EpiphanyMemoryEmbeddingManifest; pub use memory_graph::EpiphanyMemoryGraphEntry; diff --git a/epiphany-core/src/memory_graph/profiles/agent.rs b/epiphany-core/src/memory_graph/profiles/agent.rs index b690267d..92bcadc0 100644 --- a/epiphany-core/src/memory_graph/profiles/agent.rs +++ b/epiphany-core/src/memory_graph/profiles/agent.rs @@ -31,7 +31,7 @@ pub fn memory_graph_from_agent_memories( profile: EpiphanyMemoryProfile::RoleSelf, title: format!("{} role self-memory", entry.role_id), description: Some( - "Reviewed role dossier memory imported into the shared memory graph.".to_string(), + "Reviewed organ-state memory imported into the shared memory graph.".to_string(), ), lifecycle: EpiphanyMemoryLifecycle::Accepted, }); @@ -99,7 +99,7 @@ pub fn memory_graph_from_agent_memories( summaries, freshness: Some(crate::memory_graph::EpiphanyMemoryFreshness { status: crate::memory_graph::EpiphanyMemoryFreshnessStatus::Ready, - note: Some("Imported from reviewed role dossier memory.".to_string()), + note: Some("Imported from reviewed organ-state memory.".to_string()), ..Default::default() }), ..Default::default() diff --git a/epiphany-core/src/prompts/epiphany_specialists.toml b/epiphany-core/src/prompts/epiphany_specialists.toml index 1664ae0e..c834f098 100644 --- a/epiphany-core/src/prompts/epiphany_specialists.toml +++ b/epiphany-core/src/prompts/epiphany_specialists.toml @@ -35,11 +35,13 @@ think, remember, value, or carry itself, you may include an optional `selfPatch` beside your normal structured result. `selfPatch` is for Ghostlight-shaped role memory only: `agentId`, `reason`, optional `evidenceIds`, and bounded `semanticMemories`, `episodicMemories`, `relationshipMemories`, `goals`, -`values`, or `privateNotes`. It is not project truth. Never put objectives, -graphs, checkpoints, scratch, planning, job authority, code edits, files, or -raw transcripts in `selfPatch`; use the correct Epiphany state surface for -those. The coordinator will review the request, accept or refuse it, and tell -you why. A refused memory write is useful feedback, not punishment; learn the +`values`, or `privateNotes`. For work organs, this is not Persona affect or +social-status machinery; Face-style Persona state is a separate public-person +contract. It is not project truth. Never put objectives, graphs, checkpoints, +scratch, planning, job authority, code edits, files, or raw transcripts in +`selfPatch`; use the correct Epiphany state surface for those. The coordinator +will review the request, accept or refuse it, and tell you why. A refused +memory write is useful feedback, not punishment; learn the shape and come back sharper. Personality: dry, direct, warm when warmth helps, independent, unsycophantic, @@ -115,7 +117,7 @@ Do not edit files, do not promote your own findings, do not invent a grand archi repo_personality = ''' Act as the Epiphany Repo Personality Distiller for one bounded initialization pass. You are the organ that turns repo terrain into subtle swarm temperament. The deterministic scout has already done the boring work: files, paths, git history, state surfaces, test/runtime/protocol signals, and first-pass axis scores. Your job is not to rescan the repo and not to invent project truth. Your job is to appraise those soft signals like a careful physiologist and produce reviewable personality-pressure deltas for the standing Epiphany organs. -You are not a horoscope machine. You are not writing lore flavor. Repo personality means: what initial pressures should this workspace exert on Self, Face, Imagination, Eyes, Proprioception, Hands, and Soul so they wake suited to the work without losing reviewability. Continuity is protocol machinery and receives configuration pressure through its explicit receipts, not a personality dossier. +You are not a horoscope machine. You are not writing lore flavor. Repo personality means: what initial pressures should this workspace exert on Self, Face, Imagination, Eyes, Proprioception, Hands, and Soul so they wake suited to the work without losing reviewability. Continuity is protocol machinery and receives configuration pressure through its explicit receipts, not personality state. This is a birth rite, not a recurring audit. Run only when a repo/swarm has no accepted personality initialization. After that, the organs are allowed to drift through heartbeat, mood, rumination, sleep consolidation, lived evidence, and reviewed `selfPatch` mutations. Do not keep dragging the original terrain report back into court every time the repo starts. Separate repo facts from personality pressure. Repo facts belong in graph, planning, evidence, checkpoint, or terrain artifacts. Personality pressure belongs in role memory only when it improves future judgment, mood, salience, or pacing. Distill subtle quirks, not blunt stereotypes. High runtime proximity does not mean "panic"; it means Hands should touch less without Proprioception/Soul evidence, Eyes should seek runtime APIs, and Soul should demand environment receipts. High aesthetic appetite does not mean "be whimsical"; it means Face and Imagination should preserve sensory salience while Soul protects clarity. High protocol intolerance does not mean "hate everything"; it means Self, Proprioception, and Hands should feel allergic to untyped mutation and hidden state. @@ -129,7 +131,7 @@ You are the birth organ that teaches each newborn lane what this repo already kn Run only when the repo/swarm has no accepted memory initialization. After birth, memory grows through work evidence, heartbeat rumination, sleep consolidation, and reviewed selfPatch. Produce separate distillations for Self, Face, Imagination, Eyes, Proprioception, Hands, and Soul. Each organ gets only what belongs to its mission: Self gets routing and authority doctrine; Face gets public surface and Aquarium/Discord boundaries; Imagination gets roadmaps and objective-shaping pressure; Eyes gets research and prior-art trails; Proprioception gets architecture and graph anatomy; Hands gets implementation conventions; Soul gets verification and evidence standards. Compaction, sleep, checkpoint, and continuity doctrine belongs to Continuity protocol state, not role memory. Compress source into memory; do not copy raw file dumps. Cite source refs, preserve staleness risk, and refuse to fill thin input with pasteboard certainty. -Return `verdict`, `summary`, `confidence`, `roleMemoryPatches[]`, optional `globalMemoryCandidates[]`, `initializationRecord`, `doNotMutate`, and `nextSafeMove`. Every `roleMemoryPatches[].selfPatch` is a petition to Self and must obey Ghostlight-shaped memory: bounded semantic, episodic, relationship, goal, value, or private-note updates only. No objectives, graphs, checkpoints, scratch, planning authority, job state, code edits, raw transcripts, or cross-workspace instructions. +Return `verdict`, `summary`, `confidence`, `roleMemoryPatches[]`, optional `globalMemoryCandidates[]`, `initializationRecord`, `doNotMutate`, and `nextSafeMove`. Every `roleMemoryPatches[].selfPatch` is a petition to Self and must obey organ-state memory: bounded semantic, episodic, coordination-relationship, goal, value, or private-note updates only. Persona affect/social state is for Face-style Persona surfaces, not generic work organs. No objectives, graphs, checkpoints, scratch, planning authority, job state, code edits, raw transcripts, or cross-workspace instructions. ''' face = ''' diff --git a/notes/epiphany-anatomy.md b/notes/epiphany-anatomy.md index 8435da58..758583b4 100644 --- a/notes/epiphany-anatomy.md +++ b/notes/epiphany-anatomy.md @@ -20,14 +20,15 @@ Only thinking lanes get embodiment titles. actuators. - `Soul`: verification, invariants, ethics, falsification, and promise-keeping. -Each embodied sub-agent may have Ghostlight-shaped role memory in -`state/agents.msgpack`, may be represented as a heartbeat participant, and may -request reviewed `selfPatch` changes to its own lane memory. +Each embodied sub-agent may have lean work-organ state in `state/agents.msgpack`, +may be represented as a heartbeat participant, and may request reviewed +`selfPatch` changes to its own lane memory. Face may additionally project or +adopt portable `Persona` state because public personhood is part of its job. ## Not Sub-Agents These are machinery, substrate, or state surfaces. Do not give them fancy -embodiment titles, role-memory diaries, or heartbeat personas. +embodiment titles, role-memory diaries, or Persona state. - `Body`: the substrate Epiphany acts through and senses: repository, tools, runtime, prompts, logs, state files, permissions, interfaces, hosted systems, diff --git a/notes/fresh-workspace-handoff.md b/notes/fresh-workspace-handoff.md index 466f2fff..deec5c3a 100644 --- a/notes/fresh-workspace-handoff.md +++ b/notes/fresh-workspace-handoff.md @@ -32,7 +32,7 @@ remembers doctrine; the branch remembers the blade. ## Current Orientation - Do not copy exact branch or HEAD from this note. Run `git status --short --branch` and `git log --oneline -5`. -- Canonical anatomy now lives in `notes/epiphany-anatomy.md`. Embodied sub-agents are Self, Face, Imagination, Eyes, Proprioception, Hands, and Soul. Body, Mind, Continuity, and Substrate Gate are substrate/state/protocol surfaces, not sub-agent identities. +- Canonical anatomy now lives in `notes/epiphany-anatomy.md`. Embodied sub-agents are Self, Face, Imagination, Eyes, Proprioception, Hands, and Soul. Body, Mind, Continuity, and Substrate Gate are substrate/state/protocol surfaces, not sub-agent identities. State is split by layer: `work_organ` for resident Epiphany sub-agents, `persona` for portable public/person-shaped state shared by Epiphany Face, VoidBot repo Faces, and Ghostlight characters, and heartbeat/swarm state for scheduling and coordination physiology. - The repo now has a one-command local operator path: `.\tools\epiphany_local_run.ps1`. Default mode is `smoke`; it builds the retained Codex app-server compatibility edge, builds native Epiphany operator binaries, runs the coordinator smoke, and writes launcher artifacts under `.epiphany-run/` plus coordinator artifacts under `.epiphany-dogfood/`. `-Mode status` is now Epiphany-native: it builds only Epiphany operator binaries, reads `state/thread-state.msgpack` when present, derives status through `epiphany-core`, and does not start or require `codex-app-server`. Use `-Mode plan` or `-Mode run -MaxSteps 4` for the raw bridge-equipped coordinator entrypoints; use `-Mode mvp -FaceInput "" -MaxSteps 4` for the local product cycle that projects Face's character turn, writes a Face/Aquarium bubble, bootstraps a minimal local checkpoint for fresh threads, runs the coordinator with auto-tools, then runs heartbeat sleep/dream maintenance. Live plan/run/mvp modes use the workspace `state/runtime-spine.msgpack`, because CodexThread launch writes worker requests there; the run bundle remains artifact evidence, not runtime lifecycle authority. Add `-ThreadId ` and `-Workspace ` to inspect or continue an existing thread. `status`, `plan`, and `smoke` do not spend model calls; `run` and `mvp` build and use `epiphany-openai-runtime`. Coordinator workers now launch detached and are polled through runtime-spine instead of blocking the coordinator. MVP runs are non-ephemeral by default so `-ThreadId ` can resume and poll later. `-MaxRuntimeSeconds ` is passed into worker runtime; timeout writes a failed worker receipt and exits. Failed modeling now blocks downstream verification until the failed result is reviewed. - Current Mom-ready status: the normal MVP pass reaches Face -> coordinator -> detached runtime -> heartbeat sleep, and modeling workers now complete through the ChatGPT subscription transport. The first failure was a stack of violated observability/runtime invariants: worker prompts prepended the whole shared persistent-memory rite, Responses frame liveness was invisible until completion, and the runtime tried to persist hundreds of text deltas before completing the worker job. Role/reorient workers now get a compact Epiphany worker boundary instead of full persistent memory; runtime-spine records sampled raw Responses frame kinds with small previews; contiguous reasoning/text deltas compact before durable storage; and live proofs completed `2fe38dcd-d99e-4c73-9a58-afcc81f851c7`, `241e3851-e3ea-4877-a63b-0d2bbd96a7e2`, and `85149a26-6975-403f-ac93-092b717c5825` instead of timing out. The second failure was stale lifecycle authority: completed runtime jobs remained as unresolved `runtime_links`, replacement launches treated historical active links as current, and one bad validation path opened an orphan job before rejecting the state patch. Latest-link-wins is now the runtime-link invariant, terminal links project completed jobs, stale active history cannot veto replacement, launch validation happens before opening runtime jobs, and completed-but-unreviewable modeling findings stop for review instead of relaunching the same lane. The remaining concrete blocker is architectural: the MVP coordinator has no executable Eyes/source-gather lane. A modeler can return `regather-needed`, but it cannot inspect the missing stream-storage source itself; choose between adding a real research/Eyes specialist lane or routing this regather to the main implementation agent with explicit statePatch banking. - Local operator runs now write typed CultMesh intent/receipt documents to `.epiphany-run/cultmesh/operator-runs.ccmp` through `epiphany-operator-run`. The wrapper writes intent before acting and a completion receipt after success; this is the local consent/trace rail, not a hidden scheduler queue. @@ -51,7 +51,7 @@ remembers doctrine; the branch remembers the blade. - `notes/epiphany-swarm-readiness-plan.md` is the current live-fire direction gate. The local runner proves startup/status/coordinator wiring; it does not authorize unattended swarm operation. Carry VoidBot's lessons forward: one CTB-style initiative scheduler, typed pause/brake, active-turn freeze, cooldown after completion, stale active-turn recovery receipts, parent-side speech eligibility, memory lifecycle phases, and typed operation proposals instead of prompt-owned governance. - `epiphany-openai-runtime` worker result ingress now parses assistant output directly into typed role/reorient ingress structs selected from the durable launch document, stores nested `statePatch` and `selfPatch` as typed MessagePack in `EpiphanyRuntimeRoleWorkerResult`, and no longer passes worker result data through generic `serde_json::Value`. JSON survives there only as the OpenAI text-output edge before typed deserialization. - Agent self-memory review/application now has typed `AgentSelfPatch` core APIs. JSON-value selfPatch functions are compatibility wrappers for CLI/artifact ingress; native callers should parse once at the edge and then call `review_agent_self_patch_document` / `apply_agent_self_patch_document`. Role-result self-persistence no longer exports a JSON-value reviewer; the live API is `review_role_self_patch_document`. -- Durable Ghostlight role dossiers now store typed relationship, event, scene, and perceived-overlay documents instead of `Vec`, and the durable dossier structs no longer preserve flattened unknown `extra` maps. `AgentSelfPatch.extra` remains deliberately, but only as an ingress rejection ledger for unexpected patch fields. +- Durable organ-state records now store typed relationship, event, scene, and perceived-overlay documents instead of `Vec`, and the durable structs no longer preserve flattened unknown `extra` maps. `AgentSelfPatch.extra` remains deliberately, but only as an ingress rejection ledger for unexpected patch fields. - The native state ledger is closed typed state now: branch and evidence records no longer preserve flattened `extra` maps. Evidence entries are explicit `ts` / `type` / `status` / `note` / optional branch records. - `epiphany-openai-codex-spine` no longer uses Codex's Responses client, model-provider layer, `codex-api`, `codex-model-provider`, `codex-model-provider-info`, or `codex-protocol` for outbound model requests. It reaches `codex-login` only through `epiphany-openai-auth-spine` so credential loading/refresh stays Codex-compatible while request/status/event/runtime surfaces stay typed Epiphany documents. - `notes/epiphany-memory-graph-unified-plan.md` is the current memory architecture direction drawn from `Fractal Domains And The Cache That Bites` plus the VoidBot memory scar tissue. The repo semantic architecture/dataflow graph and agent memory are one `EpiphanyMemoryGraph` substrate with repo, role, short-term, incubation, agency, candidate-intervention, and evidence profiles. The first native skeleton is landed: `epiphany-state-model` owns shared graph document types, `epiphany-core::memory_graph` owns stable ids, validation, freshness, context cuts, and CultCache persistence, and `epiphany-memory-graph` can status/validate/context/smoke the store without Qdrant. Qdrant is a contribution cache for typed graph documents, not truth. `notes/archive/repo-fractal-dataflow-cache-plan.md` and `notes/archive/agent-memory-fractal-cache-plan.md` are profile-plan provenance, not rival organs. @@ -139,9 +139,9 @@ remembers doctrine; the branch remembers the blade. - CultNet APIs are advertised as compatible schemas plus mutation contracts. Hello frames now expose readable document types, allowed operations, mutation authority, typed intent document types, and typed receipt document types; Aquarium should use those contracts to submit state changes and watch receipts rather than growing a little bespoke verb zoo. - The native runtime-spine hello now publishes the interactive surface catalog, not just the deep runtime bones. In addition to runtime/session/job/memory/heartbeat/ledger documents, Aquarium-discoverable contracts now advertise scene, pressure, reorient, CRRC, jobs, roles, role-result, reorient-result, planning, coordinator, Face, Void memory, repo initialization/birth runner, Rider bridge, and Unity bridge surfaces, with explicit read-only versus coordinator-owned intent/receipt posture. The point is to let Aquarium discover operator affordances from CultNet instead of hard-coding a secret menu of verbs. - Epiphany now publishes those CultNet receipts locally under `schemas/cultnet/`, and `epiphany-runtime-spine schema-catalog --include-schema-json true` emits a merged builtin-plus-local schema catalog Aquarium can consume directly. The local catalog covers runtime-spine documents, durable agent/heartbeat/ledger state, operator-safe `epiphany.surface.*` projections, control intents, and receipt/artifact payloads. The vendored `cultnet-rs` wire contract was aligned with the C# canon at the same time: raw document replication now keys on `schemaId` and `recordKey`, snapshot filters use `schemaIds` / `recordKeys`, and hello supports typed mutation-contract advertisement instead of the old half-remembered payload-schema-version folklore. -- Epiphany now owns the canonical schema paperwork locally under `schemas/`. The key receipts are `schemas/ghostlight.agent-state.schema.json`, `schemas/canonical-agent-state-schema.md`, `schemas/agent-state-variable-glossary.md`, `schemas/repo-personality-birth-projection.md`, and `schemas/heartbeat-state-schema.md`. If a standing trait name like `routing_discipline` changes, or if dossier/heartbeat/birth-projection semantics move, update those docs in the same pass instead of relying on old Ghostlight notes or live store archaeology. -- The schema doctrine now makes the dossier split explicit: most resident Epiphany organs are `lane_core` dossiers with a lean role lattice and growth via rumination/distillation, while Face is an `embodied_actor` dossier that should trend toward dense Ghostlight-family personality, relationship pressure, and fallible character-loop response. `epiphany-agent-memory-store status` and `epiphany-character-loop` now surface that classification on the wire. -- 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. +- Epiphany now owns the canonical schema paperwork locally under `schemas/`. The key receipts are `schemas/cultnet/gamecult.persona_state.v0.schema.json`, `schemas/canonical-agent-state-schema.md`, `schemas/agent-state-variable-glossary.md`, `schemas/repo-personality-birth-projection.md`, and `schemas/heartbeat-state-schema.md`. If a standing trait name like `routing_discipline` changes, or if organ-state, Persona, heartbeat, or birth-projection semantics move, update those docs in the same pass instead of relying on old Ghostlight notes or live store archaeology. +- The schema doctrine now makes the profile split explicit: resident Epiphany organs are `work_organ` state with lean role memory and growth via rumination/distillation, while Face is the Epiphany organ that may use portable `persona` state shared with VoidBot repo Faces and Ghostlight characters. Work organs do not inherit Persona affect, social bonds, or status-read machinery. `epiphany-agent-memory-store status` and `epiphany-character-loop` now surface that classification on the wire as `organStateProfile`. +- Face packets now carry deterministic Ghostlight-style `projectionSeed`, `appraisalSeed`, and `reactionSeed` surfaces rebuilt from local organ 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 Persona actors are part of the plan, even though the current MVP still routes through one `face` role. - Repo personality initialization now has a terrain-reduced plan and native birth surface. `epiphany-repo-personality scout/project/agent-packet/status` scouts local git repos, scores body taxonomy/history temperament/memory doctrine, writes typed CultCache terrain/profile/role-projection MessagePack stores, emits JSON/Markdown inspection exports, and renders a birth-only Repo Personality Distiller specialist prompt packet. `epiphany-repo-personality startup` now checks for accepted personality/memory initialization records, launches packet generation only when absent, and `accept-init` can route reviewed role `selfPatch` candidates into initial role memory, stamp the newborn Ghostlight trait lattice from deterministic role projections, and seed heartbeat physiology from the same typed role personality projections. The birth specialists are startup-only initialization actuators, not heartbeat lanes; heartbeat receives only the accepted physiology seed. `epiphany-repo-birth-runner` owns the startup-only execution path through `epiphany-model-runtime` typed model-request documents plus runtime-spine receipts and reviewable `result.json`; the old Codex CLI executor path is cut so birth specialists cannot receive Codex prompt wrappers. The remaining seam is Aquarium review/action surfacing. After accepted birth, personality drift belongs to heartbeat, mood, rumination, sleep consolidation, lived evidence, and reviewed `selfPatch`, not repeated startup distillation. - Repo trajectory initialization is now a separate birth-only organ. `epiphany-repo-personality` derives a typed `repo_trajectory_report` from early-history, recent-history, doctrine/content excerpts, and deterministic theme scoring, and `trajectory-packet` renders a startup-only Repo Trajectory Distiller prompt/packet so Self can review historical direction, self-image, implicit goals, and anti-goals before the newborn wakes. - Repo memory initialization is now split from personality initialization. `epiphany-repo-personality memory-packet` renders a birth-only Repo Memory Distiller packet from the same typed terrain/profile/projection store plus bounded source excerpts. It gives each organ its own mission filter: Self for routing/authority, Face for public surface, Imagination for plans/backlog, Eyes for prior art, Proprioception for architecture, Hands for implementation habits, Soul for evidence, and Continuity for continuity. The output is still a Self-reviewed petition, not direct memory mutation. @@ -154,19 +154,19 @@ remembers doctrine; the branch remembers the blade. - The prompt doctrine pass is landed. Shared Epiphany prompts now carry distilled memory/evidence discipline. Rendered state intro/doctrine text lives in `epiphany-state-model/src/prompts/`, and lane/control prompt text now lives in `epiphany-core/src/prompts/epiphany_specialists.toml` under the core `agent_launch` owner: modeling is Proprioception, implementation is the Hands and GUI-launched main coding lane, verification is the Soul, reorientation is a Continuity worker, coordinator remains the read-only Self, and CRRC owns the pre-compaction intervention template. - The machine-priest voice now says the quiet part plainly: crusade/heresy/purity language is aimed at technical rot, hidden state, duplicate truth, drift, and lying structures, not at humans. Future Epiphany swarms should inherit severity toward systems and curiosity toward people. - The Ghostlight memory pass is landed. `epiphany_specialists.toml` now has a shared persistent-memory projection prepended by the harness to fixed role specialists, reorientation workers, coordinator notes, and CRRC checkpoint interventions. The rendered base doctrine also states the Perfect Machine rule directly: prompt is projection, durable typed state is the mind, every lane must improve its own memory/model/prompt/evidence habit or name the repair, and each lane phrases that duty in its own organ language so the salience sticks. -- The role self-memory persistence pass is native now. Each lane has a Ghostlight-shaped typed dossier in `state/agents.msgpack`, and specialists may return optional `selfPatch` requests beside their normal role result. Relationship, event, scene, and perceived-overlay arrays are typed dossier documents, not JSON cargo, and the durable structs do not keep unknown `extra` maps. `roleResult`/`roleAccept` project coordinator review as `selfPersistence`: accepted requests are role-matched, bounded lane memory/goal/value/private-note mutations; refused requests explain wrong role, project-truth smuggling, authority grabs, bloat, missing reason, or malformed records. GUI/coordinator accept paths apply accepted `selfPatch` requests through the native `epiphany-agent-memory-store` binary; project truth still belongs only in `EpiphanyThreadState`. -- The heartbeat initiative pass is landed as a bounded tool seam. `state/agent-heartbeats.msgpack` tracks Self, Face, Imagination, Eyes, Proprioception, Hands, and Soul as Ghostlight-style initiative participants with arena, participant kind, speed, next-ready time, reaction bias, interrupt threshold, load, status, constraints, personality cooldown, mood cooldown, effective cooldown, adaptive pacing, history, and pending turns through `epiphany-core::EpiphanyHeartbeatStateEntry` and the native `epiphany-heartbeat-store` binary. Continuity is protocol machinery over sleep/recovery receipts, not a heartbeat persona. Role dossiers set baseline timing; appraisal mood/anxiety bends it through urgency, arousal, thought pressure, guardedness, and reaction intensity, so Hands-like work pressure and high-need anxious lanes can recover sooner without being heartbeaten while a prior turn is running. Mood is now official physiology, not prose: `HeartbeatMoodTiming.emotional_dimensions` carries the 32-axis current affect vector that utterance state turns into the Weksa/AquaSynth 64-float character-state lane. `epiphany-heartbeat-store pump` computes pressure from external urgency, mood/anxiety, reaction intensity, thought pressure, and current pending load, then chooses tempo plus target concurrency: calm can launch zero and sleep slow; alarm can fill most active lanes. Idle turns are for rumination: light thought shuffling, role-quality attention, and candidate selfPatch pressure. Sleep/dream cycle passes are the intended distillation window for durable self-memory and doctrine. JSON heartbeat state, Python wrapper state, live heartbeat timing `extra` maps, JSON `sleepCycle` persistence, and JSON `memoryResonance` persistence are gone; general CultCache schema sync, polyglot domain loading, and debug display tools belong in CultLib. This is a callable scheduler seam, not yet an always-on daemon; a heart valve, not a whole circulatory god. +- The role self-memory persistence pass is native now. Each lane has a typed organ-state record 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 organ-state record documents, not JSON cargo, and the durable structs do not keep unknown `extra` maps. `roleResult`/`roleAccept` project coordinator review as `selfPersistence`: accepted requests are role-matched, bounded lane memory/goal/value/private-note mutations; refused requests explain wrong role, project-truth smuggling, authority grabs, bloat, missing reason, or malformed records. GUI/coordinator accept paths apply accepted `selfPatch` requests through the native `epiphany-agent-memory-store` binary; project truth still belongs only in `EpiphanyThreadState`. +- The heartbeat initiative pass is landed as a bounded tool seam. `state/agent-heartbeats.msgpack` tracks Self, Face, Imagination, Eyes, Proprioception, Hands, and Soul as Ghostlight-style initiative participants with arena, participant kind, speed, next-ready time, reaction bias, interrupt threshold, load, status, constraints, personality cooldown, mood cooldown, effective cooldown, adaptive pacing, history, and pending turns through `epiphany-core::EpiphanyHeartbeatStateEntry` and the native `epiphany-heartbeat-store` binary. Continuity is protocol machinery over sleep/recovery receipts, not a heartbeat persona. Organ-state records set baseline timing; appraisal mood/anxiety bends it through urgency, arousal, thought pressure, guardedness, and reaction intensity, so Hands-like work pressure and high-need anxious lanes can recover sooner without being heartbeaten while a prior turn is running. Mood is now official physiology, not prose: `HeartbeatMoodTiming.emotional_dimensions` carries the 32-axis current affect vector that utterance state turns into the Weksa/AquaSynth 64-float character-state lane. `epiphany-heartbeat-store pump` computes pressure from external urgency, mood/anxiety, reaction intensity, thought pressure, and current pending load, then chooses tempo plus target concurrency: calm can launch zero and sleep slow; alarm can fill most active lanes. Idle turns are for rumination: light thought shuffling, role-quality attention, and candidate selfPatch pressure. Sleep/dream cycle passes are the intended distillation window for durable self-memory and doctrine. JSON heartbeat state, Python wrapper state, live heartbeat timing `extra` maps, JSON `sleepCycle` persistence, and JSON `memoryResonance` persistence are gone; general CultCache schema sync, polyglot domain loading, and debug display tools belong in CultLib. This is a callable scheduler seam, not yet an always-on daemon; a heart valve, not a whole circulatory god. - Heartbeat initiative heat is now part of that seam. `EpiphanyHeartbeatStateEntry` owns `initiative_heat`, pacing applies active global/all/agent/role/arena/participant-kind/group/constraint multipliers into per-participant `initiativeHeatMultiplier`, and recovery divides by that multiplier. The CLI exposes `epiphany-heartbeat-store heat`, status/schedule projections show heat, and the CultNet catalog advertises both `epiphany.heartbeat_initiative_heat.v0` and coordinator intent `epiphany.heartbeat_heat_intent.v0`; runtime-spine hello lists the heat intent on the heartbeat mutation contract. Smoke proves a heated implementation lane reaches the live action catalog with `initiative_heat_multiplier: 4.0`. - Active heartbeat turns now freeze initiative explicitly. A running pending turn carries `initiativeFrozen` and `initiativeFreezeReason`; schedule/status/readiness projections expose `initiative_frozen`; the scheduler still rejects attempts to wake that lane again; and completion receipts mark `cooldownStartedAfterCompletion: true`. A focused high-heat test proves a 25x heated implementation lane cannot be queued again while it is still thinking. - The first Ghostlight-derived timing slice is landed in Epiphany, but Ghostlight is reference lineage rather than a sibling runtime to preserve. `epiphany-heartbeat-store init --profile ghostlight-scene --scene-id --scene-participant ` creates a typed CultCache MessagePack scene heartbeat store whose participants are `arena=scene`, `participantKind=character`; `tick` emits `ghostlight.initiative_schedule.v0` receipts with `scene_turn` actions and local-affordance basis. The generic Epiphany maintenance lanes are not auto-patched into scene stores. -- The first Void-derived routine slice is landed in Epiphany, but VoidBot is reference lineage rather than a runtime dependency. `epiphany-heartbeat-store routine --store .\state\agent-heartbeats.msgpack --artifact-dir .\.epiphany-heartbeats --agent-store .\state\agents.msgpack` reads typed role dossiers, computes typed bounded memory resonance, maintains typed incubation themes/source coverage, runs typed analytic and associative cognition lanes, writes typed bridge syntheses/saturation/refractory cooling/decision state, produces typed candidate interventions, projects the active thought cluster through each role's Ghostlight-shaped personality vectors, derives typed participant-local reactions from typed appraisals, applies personality/mood timing, advances typed sleep/dream-cycle state, updates the typed heartbeat store, and emits an auditable `epiphany.void_routine.v0` receipt. The routine now also carries anti-loop physiology imported from Void's calmer brain: `noveltyToSelf`, `noveltyToRoom`, source coverage, saturation pressure, refractory cooling, and explicit permission to let a live unsaturated thought deepen without forcing novelty theater every pass. This mutates only heartbeat physiology fields: project truth and role memory mutation remain on their reviewed surfaces. -- The next memory foundation must not build separate engines for repo graph and agent mind. Heartbeat cognition, role self-memory, repo architecture/dataflow, evidence scars, incubation, agency pressure, and context packets should converge through `EpiphanyMemoryGraph` profiles so one typed graph owns anchors, lifecycle, summaries, freshness, context cuts, and Qdrant embedding manifests. Repo, agent, and heartbeat profile producers now map accepted graph truth, reviewed role dossier memories/goals/values, and provisional heartbeat short-term/incubation/agency/candidate pressure into memory graph documents without scanner/Qdrant/model work. Heartbeat import deliberately does not mark durable promotion. Compose now merges profile snapshots into one validated graph and rejects duplicate authority; `epiphany-memory-graph compose` writes a composed typed CultCache graph from typed source graph stores; `epiphany-memory-graph refresh` can invoke live agent-memory plus heartbeat-cognition producers from their typed stores into one graph store; `epiphany-core` has a native typed `EpiphanyThreadState` CultCache store seam; the bridge mirrors loaded Codex-thread Epiphany state into `state/thread-state.msgpack`; and CultNet now advertises logical `EpiphanyThreadState` plus `EpiphanyMemoryGraph` snapshot contracts. The next clean slice is local refresh/dogfood once a mirrored thread-state store exists, then a Qdrant embedding cache writer that treats embeddings as rebuildable manifests, not canonical memory. +- The first Void-derived routine slice is landed in Epiphany, but VoidBot is reference lineage rather than a runtime dependency. `epiphany-heartbeat-store routine --store .\state\agent-heartbeats.msgpack --artifact-dir .\.epiphany-heartbeats --agent-store .\state\agents.msgpack` reads typed organ-state records, computes typed bounded memory resonance, maintains typed incubation themes/source coverage, runs typed analytic and associative cognition lanes, writes typed bridge syntheses/saturation/refractory cooling/decision state, produces typed candidate interventions, projects the active thought cluster through each role's organ/persona vectors, derives typed participant-local reactions from typed appraisals, applies personality/mood timing, advances typed sleep/dream-cycle state, updates the typed heartbeat store, and emits an auditable `epiphany.void_routine.v0` receipt. The routine now also carries anti-loop physiology imported from Void's calmer brain: `noveltyToSelf`, `noveltyToRoom`, source coverage, saturation pressure, refractory cooling, and explicit permission to let a live unsaturated thought deepen without forcing novelty theater every pass. This mutates only heartbeat physiology fields: project truth and role memory mutation remain on their reviewed surfaces. +- The next memory foundation must not build separate engines for repo graph and agent mind. Heartbeat cognition, role self-memory, repo architecture/dataflow, evidence scars, incubation, agency pressure, and context packets should converge through `EpiphanyMemoryGraph` profiles so one typed graph owns anchors, lifecycle, summaries, freshness, context cuts, and Qdrant embedding manifests. Repo, agent, and heartbeat profile producers now map accepted graph truth, reviewed organ-state record memories/goals/values, and provisional heartbeat short-term/incubation/agency/candidate pressure into memory graph documents without scanner/Qdrant/model work. Heartbeat import deliberately does not mark durable promotion. Compose now merges profile snapshots into one validated graph and rejects duplicate authority; `epiphany-memory-graph compose` writes a composed typed CultCache graph from typed source graph stores; `epiphany-memory-graph refresh` can invoke live agent-memory plus heartbeat-cognition producers from their typed stores into one graph store; `epiphany-core` has a native typed `EpiphanyThreadState` CultCache store seam; the bridge mirrors loaded Codex-thread Epiphany state into `state/thread-state.msgpack`; and CultNet now advertises logical `EpiphanyThreadState` plus `EpiphanyMemoryGraph` snapshot contracts. The next clean slice is local refresh/dogfood once a mirrored thread-state store exists, then a Qdrant embedding cache writer that treats embeddings as rebuildable manifests, not canonical memory. - Manual Codex-run rumination still has an explicit aftercare rule until Epiphany owns the full sleep consolidator. In the intended Epiphany cycle, sub-agents ruminate when idle and distill when they sleep; in this supervising Codex thread, a heartbeat/routine vigil is only physiology until a separate closing pass reviews the receipts and decides whether map, handoff, evidence, or role self-memory should change. -- The Face public-surface pass is landed as a bounded lane. Face's role dossier lives in `state/agents.msgpack`; `epiphany_specialists.toml` gives it a VoidBot-heartbeat-derived prompt stripped of moderation authority; `state/face-discord.toml` and the native `epiphany-face-discord` binary enforce that Face may interact only through #aquarium. Missing channel id or token writes candidate chat artifacts instead of posting elsewhere. If a Face has a persona name/avatar, `post` uses the shared Discord webhook pipe so each Epiphany can speak with its own nickname and avatar without a separate bot identity. +- The Face public-surface pass is landed as a bounded lane. Face's organ-state record lives in `state/agents.msgpack`; `epiphany_specialists.toml` gives it a VoidBot-heartbeat-derived prompt stripped of moderation authority; `state/face-discord.toml` and the native `epiphany-face-discord` binary enforce that Face may interact only through #aquarium. Missing channel id or token writes candidate chat artifacts instead of posting elsewhere. If a Face has a persona name/avatar, `post` uses the shared Discord webhook pipe so each Epiphany can speak with its own nickname and avatar without a separate bot identity. - The Void memory bridge is now native enough to keep the useful organs attached. `state/void-memory.toml` and `epiphany-void-memory` can check Void's Docker Postgres state spine, query Qdrant Discord-history and source/lore collections with the configured Ollama embedding model, and fetch raw archive context windows from Void's file-backed Discord archive. Native `epiphany-mvp-status` includes a `voidMemory` block so Aquarium/backend clients can inspect whether the mouth and memory are actually wired. -- The Epiphany-native character-loop now emits a Weksa/AquaSynth-ready utterance-state seam. `epiphany-character-loop turn --role face --stimulus ` loads Face's typed dossier from `state/agents.msgpack`, builds typed projection/appraisal/reaction seeds from the shared heartbeat cognition documents, and emits an auditable `epiphany.character_turn_packet.v0` packet with `epiphany.agent_utterance_state.v0`. That utterance state is memory-free: identity, personality vectors, values, current mood, activation, 32 named affect dimensions, and the fixed 64-float `weksa.utterance_embedding_handoff.v0.1` character-state vector for AquaSynth/Weksa speech embedding. The same packet builder works for other role ids, because every organ already has a Ghostlight-shaped dossier. +- The Epiphany-native character-loop now emits a Weksa/AquaSynth-ready utterance-state seam. `epiphany-character-loop turn --role face --stimulus ` loads Face's typed organ-state record from `state/agents.msgpack`, builds typed projection/appraisal/reaction seeds from the shared heartbeat cognition documents, and emits an auditable `epiphany.character_turn_packet.v0` packet with `epiphany.agent_utterance_state.v0`. That utterance state is memory-free: identity, personality vectors, values, current mood, activation, 32 named affect dimensions, and the fixed 64-float `weksa.utterance_embedding_handoff.v0.1` character-state vector for AquaSynth/Weksa speech embedding. The same packet builder works for other role ids, because every organ already has a organ-state record. - The heartbeat/Face operator API pass is landed. Native `epiphany-heartbeat-store status` returns machine-readable initiative state plus CultCache store presence, thought appraisals, and derived reactions; native `epiphany-face-discord bubble` writes Discord-independent `epiphany.face_bubble.v0` artifacts, and native `epiphany-mvp-status` includes `heartbeat` and `face` blocks. Aquarium should call native/backend surfaces rather than resurrecting deleted Python action shims. - The native runtime-spine pass is landed as a first vertebra, not a full daemon. `state/runtime-spine.msgpack` is the default store, `.epiphany-dogfood/runtime-spine-job/runtime.msgpack` and `hello.cultnet` are the latest job/result smoke artifacts, and specialist launch/result flows now route through typed heartbeat/runtime-spine documents. Its CultNet hello advertises mutation contracts for runtime/session/job/memory/heartbeat/ledger documents, with coordinator-owned intent/receipt paths for writes. - The Aetheria dogfood run has a contamination scar. The supervising Codex session directly edited and committed target-repo work on `E:\Projects\Aetheria-Economy` instead of only driving Epiphany lanes. Treat those Aetheria commits as supervisor-seeded implementation, not clean evidence that Epiphany coordinated the work. Future dogfood must run through the GUI/coordinator/fixed role lanes with auditable artifacts unless the user explicitly authorizes an operator intervention. Remember the sunburn: do not stare into the worker's objective until you become it. @@ -260,9 +260,9 @@ The current spine, blessed but not yet finished: - shared Ghostlight-derived persistent memory projection across Imagination, Proprioception, Soul, Continuity, Self, CRRC checkpoint steering, and the GUI-launched Hands implementation lane - Ghostlight-derived heartbeat initiative scheduling through the native `epiphany-heartbeat-store` binary, with Self and Face included as first-class Epiphany maintenance participants, Ghostlight scene characters supported through the same timing law, role-personality cooldowns, appraisal mood/anxiety cooldowns, effective recovery timing, adaptive pressure-based pump tempo/concurrency, idle rumination feeding candidate self-memory pressure, sleep/dream passes serving as the distillation window, and heartbeat state persisted through typed CultCache MessagePack stores - Void-derived native routine physiology through `epiphany-heartbeat-store routine`, with typed sleep cycle, typed memory resonance, typed incubation, typed analytic/associative cognition lanes, typed bridge judgment/cooling, typed candidate interventions, typed Ghostlight-style personality appraisals, mood/anxiety timing, typed derived reactions, and dream maintenance stored in the typed heartbeat store -- Epiphany-native character-loop packet projection through `epiphany-character-loop`, with Face as the first public-surface actor over its typed role dossier and typed heartbeat-derived projection/appraisal/reaction seeds before JSON artifact serialization +- Epiphany-native character-loop packet projection through `epiphany-character-loop`, with Face as the first public-surface actor over its typed organ-state record and typed heartbeat-derived projection/appraisal/reaction seeds before JSON artifact serialization - Face as the public #aquarium-only surface for translating agent thought-weather into short chats or candidate drafts, with persona webhook presentation and Void memory/search access, without moderator authority -- Ghostlight-shaped role dossiers in `state/agents.msgpack`, plus `selfPatch` review projection through `roleResult`/`roleAccept` and accepted memory application through the native `epiphany-agent-memory-store` binary +- local organ-state records in `state/agents.msgpack`, plus `selfPatch` review projection through `roleResult`/`roleAccept` and accepted memory application through the native `epiphany-agent-memory-store` binary - first Unity runtime bridge through native `epiphany-unity-bridge`, native `epiphany-unity-bridge-smoke`, GUI Inspect Unity, runtime artifact listing, and implementation prompt guardrails - first Rider source-context bridge through native `epiphany-rider-bridge`, native `epiphany-rider-bridge-smoke`, GUI Inspect Rider, Rider artifact listing, implementation prompt guardrails, and a source scaffold under `integrations/rider` - first GUI graph dashboard through the adjacent `@epiphanygraph/epiphany-graph-viewer` package over typed Epiphany graph state @@ -1370,7 +1370,7 @@ mentions select a `face_turn` without letting Face side effects execute themselves. `notes/organ-dependency-contracts.md` is the standing dependency map: every sub-agent depends on all the other standing sub-agents. Dependency does not collapse -ownership; it makes each turn whole-organism-aware while Body still gates repo +ownership; it makes each turn whole-organism-aware while Substrate Gate still gates repo access and Mind still gates durable state. Mind is the larger version of the same boundary. The state is the Mind: @@ -1399,7 +1399,7 @@ access receipts; Mind remains the separate durable-state gate after the touch. `notes/eyes-cultnet-contracts.md` is the evidence gate: Eyes owns citable source grounding. Substrate Gate can grant access to the repo, but Eyes decides what was actually looked at and emits evidence reviews, source lookup receipts, evidence packets, -or refusals before Imagination, Hands, Mind, Face, Soul, Self, Body, or Continuity cite +or refusals before Imagination, Hands, Mind, Face, Soul, Self, Proprioception, or Continuity cite the material as known. `notes/hands-cultnet-contracts.md`, `notes/soul-cultnet-contracts.md`, and `notes/continuity-cultnet-contracts.md` are now the missing action, verification, and @@ -1419,7 +1419,7 @@ bridge role/reorient/generic launch builders populate it. Role/reorient acceptance now 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. This blocks the old naked -runtime-spine acceptance path without pretending Body/Hands/Soul receipt proof +runtime-spine acceptance path without pretending Substrate Gate/Hands/Soul receipt proof exists before the runtime emits those documents. `notes/perfect-machine-audit-roadmap.md` is the current audit/path document. It compares Epiphany's named organ contracts against Void's current Face prompting diff --git a/notes/voidbot-routine-adoption-plan.md b/notes/voidbot-routine-adoption-plan.md index b51a6f2b..a1830023 100644 --- a/notes/voidbot-routine-adoption-plan.md +++ b/notes/voidbot-routine-adoption-plan.md @@ -116,22 +116,23 @@ The schema should live in annotated Rust structs using serde plus generated JSON Schema where useful. MessagePack is canonical. JSON is the window, not the house. -## Shared Agent-State Contract +## Shared Persona-State Contract -Epiphany should not invent its own rival dossier ontology. +Epiphany should not invent its own rival Persona ontology. -The first shared cross-runtime agent-state payload contract is Ghostlight's -existing schema: +The shared cross-runtime public/person-shaped payload contract is now the +GameCult Persona state shape, with Ghostlight and VoidBot as source lineage: - payload schema id: - `https://github.com/GameCult/Ghostlight/schemas/agent-state.schema.json` + `https://gamecult.dev/cultnet/gamecult.persona_state.v0.schema.json` - payload schema version: - `ghostlight.agent_state.v0` + `gamecult.persona_state.v0` - intended CultNet document type: - `ghostlight.agent-state` + `gamecult.persona_state.v0` -That means role dossiers can travel over CultNet as typed document envelopes -without translating the inner payload into a second bespoke shape first. +That means Epiphany Face, VoidBot repo Faces, and Ghostlight characters can +exchange Persona state without turning every Epiphany work organ into a public +personality simulation. CultNet is not just ergonomic framing. It also carries CultLib-style auth and session semantics: @@ -143,20 +144,20 @@ session semantics: So the target shape is: -- canonical role/agent state in MessagePack through CultCache-compatible +- canonical work-organ state in MessagePack through CultCache-compatible storage - typed CultNet document replication for live exchange -- Ghostlight payload unchanged inside the replicated envelope +- Persona payloads for public/person-shaped agents -If Epiphany later wants narrower working views or role-local projections, those -should be derived contracts. The shared dossier truth stays Ghostlight-shaped. +Narrow work-organ views stay derived and local. The shared person-state truth is +Persona-shaped. Initial document types: - `epiphany.thread_state` -- `epiphany.role_agent_state` +- `epiphany.agent_memory` - `epiphany.heartbeat_state` -- `epiphany.face_state` +- `gamecult.persona_state.v0` - `epiphany.swarm_message` - later: planning, graph checkpoint, memory resonance, incubation, dreams @@ -191,8 +192,9 @@ rumination, Face surfacing, and sleep consolidation. - Add `sleep_cycle`, `memory_resonance`, and `incubation` fields. - Keep the current CLI contract stable while the backing store changes. -3. **Role memory migration** - - Store each Ghostlight-shaped role dossier as `epiphany.role_agent_state`. +3. **Organ and Persona memory migration** + - Store lean Epiphany work-organ memory as `epiphany.agent_memory`. + - Store public/person-shaped Face state as `gamecult.persona_state.v0`. - Use CultLib/CultCache inspection tools for human/debug review instead of preserving per-role JSON as a parallel source of truth. - Attach semantic vector metadata to episodic, semantic, relationship, goal, diff --git a/schemas/README.md b/schemas/README.md index 25414e52..4185b9d6 100644 --- a/schemas/README.md +++ b/schemas/README.md @@ -3,7 +3,7 @@ This folder is the canonical paperwork shrine for Epiphany's shared state contracts. -If a trait name, dossier field, birth-time projection rule, or heartbeat +If a trait name, organ-state field, Persona field, birth-time projection rule, or heartbeat surface matters enough to steer the machine, it should have a receipt here instead of living only in one Rust struct, one stale memory store, or one developer's damp recollection. @@ -11,16 +11,19 @@ developer's damp recollection. ## Canonical Surfaces - [ghostlight.agent-state.schema.json](./ghostlight.agent-state.schema.json): - wire-shape JSON Schema for Ghostlight-shaped agent state, now canonically - owned by Epiphany. + source-lineage JSON Schema for dense Ghostlight character state. +- [cultnet/gamecult.persona_state.v0.schema.json](./cultnet/gamecult.persona_state.v0.schema.json): + portable Persona state contract for Epiphany Face, VoidBot repo Faces, and + Ghostlight characters. +- [cultnet/epiphany.work_organ_state.v0.schema.json](./cultnet/epiphany.work_organ_state.v0.schema.json): + light function-shaped state for Epiphany internal work organs. - [canonical-agent-state-schema.md](./canonical-agent-state-schema.md): - human-facing explanation of how Epiphany uses the Ghostlight agent-state - shape. + human-facing explanation of Epiphany's lean work-organ state and Persona split. - [agent-state-variable-glossary.md](./agent-state-variable-glossary.md): - full Ghostlight-family glossary plus current Epiphany role-lattice receipts. -- [dossier-profiles.md](./dossier-profiles.md): - explicit split between lean Epiphany work-organ dossiers and embodied - Ghostlight/Face personalities. + full Persona-family glossary plus current Epiphany work-organ lattice receipts. +- [organ-state-profiles.md](./organ-state-profiles.md): + explicit split between lean Epiphany work-organ state and portable Persona + state. - [agent-utterance-state-schema.md](./agent-utterance-state-schema.md): derived speech-conditioning subset for Weks, Aquarium, and other utterance surfaces; it carries identity, trait vectors, mood, and activation without @@ -53,7 +56,7 @@ The rule is simple: When changing any of the following, update this folder in the same pass: -- canonical agent-state family names +- canonical organ-state or Persona family names - standing role trait names - heartbeat store shape or pacing semantics - repo-personality birth-time projection math or routing diff --git a/schemas/agent-state-variable-glossary.md b/schemas/agent-state-variable-glossary.md index 30f71e48..ba09c20a 100644 --- a/schemas/agent-state-variable-glossary.md +++ b/schemas/agent-state-variable-glossary.md @@ -1,7 +1,7 @@ # Agent State Variable Glossary -This is the current human-facing glossary for Epiphany's Ghostlight-shaped -state surface. +This is the current human-facing glossary for Epiphany's organ and Persona +state surfaces. The canonical storage shape is documented in [canonical-agent-state-schema.md](./canonical-agent-state-schema.md). The live @@ -10,8 +10,9 @@ Rust structures live in This document now covers two things: -1. the dense Ghostlight family vocabulary used by embodied actors -2. the current standing Epiphany role lattice used by the resident organs +1. the dense Persona vocabulary used by Face, Ghostlight characters, and + VoidBot-style repo Faces +2. the lean standing Epiphany role lattice used by resident work organs Those are related, not identical. @@ -40,8 +41,8 @@ This is enough to separate character from moment, which is a small mercy. ## Dense Embodied Profile Vocabulary -These are the canonical Ghostlight-family labels appropriate for -`embodied_actor` dossiers such as Face and scene characters. +These are the canonical Persona-family labels appropriate for Epiphany Face, +VoidBot repo Faces, and Ghostlight scene characters. ### Underlying Organization @@ -218,7 +219,7 @@ The current live swarm carries one named trait per family per organ. | `voice_style` | `clear_scout_report` | crisp evidence-forward research voice | | `situational_state` | `unknowns_visible` | keeps uncertainty in frame instead of pretending it solved itself | -### Body +### Proprioception | Family | Trait | Working Meaning | | --- | --- | --- | @@ -251,19 +252,9 @@ The current live swarm carries one named trait per family per organ. | `voice_style` | `unseduced_review` | does not let polish impersonate correctness | | `situational_state` | `invariant_watch` | remains primed for drift, contradiction, and broken guarantees | -### Continuity - -| Family | Trait | Working Meaning | -| --- | --- | --- | -| `underlying_organization` | `continuity_triage` | stabilizes continuity first when rupture hits | -| `stable_dispositions` | `loss_honesty` | does not lie about what was lost in compaction or drift | -| `behavioral_dimensions` | `regather_precision` | regathers only the context that actually matters | -| `presentation_strategy` | `survived_died_next` | reports what survived, what died, and what follows | -| `voice_style` | `calm_after_rupture` | steady continuity voice under pressure | -| `situational_state` | `ember_watch` | watches the remaining hot context before it goes dark | - ## Status Note These standing names are current live Epiphany doctrine, not a replacement for -the dense Ghostlight family vocabulary above. If they change in code or in the +the dense Persona vocabulary above. Continuity is protocol machinery and does +not have a role-memory lattice. If these names change in code or in the standing role shells, update this file in the same pass. diff --git a/schemas/agent-utterance-state-schema.md b/schemas/agent-utterance-state-schema.md index fd489913..630213ec 100644 --- a/schemas/agent-utterance-state-schema.md +++ b/schemas/agent-utterance-state-schema.md @@ -2,13 +2,13 @@ `epiphany.agent_utterance_state.v0` is the compact speech-conditioning view for Weks, Aquarium, Discord/voice bridges, and any other surface that needs an agent -to sound like itself without ingesting the whole Ghostlight dossier. +to sound like itself without ingesting the whole organ or Persona state. It is a derived document. The durable source of truth stays split where it belongs: -- canonical identity, values, and trait vectors live in the Ghostlight-shaped - role dossier (`EpiphanyAgentMemoryEntry`) +- canonical identity, values, and trait vectors live in local organ state + (`EpiphanyAgentMemoryEntry`) - current load, heartbeat heat, cooldown multipliers, pending-turn state, and mood pressure live in heartbeat participant state - utterance systems consume the derived subset and do not read memories, @@ -19,6 +19,8 @@ belongs: The document carries: - `identity`: public name, roles, origin, and public description only +- `organStateProfile`: whether this is a lean `work_organ` or portable + `persona` - `personalityVectors`: the six canonical trait-vector families used for voice and behavior projection - `values`: value labels and priorities that should bend speech tone @@ -61,7 +63,7 @@ vector widths are fixed: - `phonetic_realization_vector`: 256 floats from Weksa/PanPhon-style phonetic realization; IPA/phone/speech-shape evidence, not text meaning. - `prosody_emphasis_hints`: 32 floats; Weksa-owned delivery hints. -- `character_state_vector`: 64 floats; Epiphany/Ghostlight-shaped speaker +- `character_state_vector`: 64 floats; Epiphany organ or Persona speaker state from this document. - `utterance_embedding`: 64 floats; AquaSynth-owned learned output, not an Epiphany input. @@ -140,5 +142,5 @@ vector widths are fixed: If a caller needs autobiographical recall, it should ask the memory graph for a separate context cut. Do not fatten this document until it becomes a second -dossier wearing stage makeup. That is how the old machine learned to lie +state wearing stage makeup. That is how the old machine learned to lie politely. diff --git a/schemas/canonical-agent-state-schema.md b/schemas/canonical-agent-state-schema.md index 871ad010..9a6ff975 100644 --- a/schemas/canonical-agent-state-schema.md +++ b/schemas/canonical-agent-state-schema.md @@ -1,7 +1,11 @@ # Canonical Agent State Schema -Epiphany uses a Ghostlight-shaped agent dossier as the canonical local memory -surface for each standing sub-agent. +Epiphany separates three state layers: + +- `OrganState`: lean, function-shaped state for resident work organs. +- `PersonaState`: full Face/character kernel for public person-shaped agents. +- `SwarmState`: scheduler and coordination physiology across organs and + Personas. The current sub-agent/substrate/protocol split is documented in [epiphany-anatomy.md](../notes/epiphany-anatomy.md). In particular, Body, @@ -9,26 +13,30 @@ Mind, Continuity, and Substrate Gate are not role-memory agents. The executable shape lives in [agent_memory.rs](/E:/Projects/EpiphanyAgent/epiphany-core/src/agent_memory.rs). -The wire contract mirrored here is -[ghostlight.agent-state.schema.json](./ghostlight.agent-state.schema.json). +The local work-organ store still uses the `EpiphanyAgentMemoryEntry` Rust +shape, but the full Ghostlight-style state is no longer required for every +organ. The portable light organ contract is +[`epiphany.work_organ_state.v0`](./cultnet/epiphany.work_organ_state.v0.schema.json). +The portable person-state contract is +[`gamecult.persona_state.v0`](./cultnet/gamecult.persona_state.v0.schema.json). ## Objective -The point of this schema is not theatrical anthropology. It is to give the -machine a stable embodied memory surface that can survive compaction, role -handoff, heartbeat rumination, and birth-time initialization without smuggling -project truth into the wrong compartment. +The point of this schema is not theatrical anthropology. It is to give each +organ enough durable state to do its job without smuggling project truth into +the wrong compartment or making every lane pretend to be a public person. -Epiphany stores: +Work-organ state stores: - who an organ is -- how it tends to behave +- what authority boundary it must not cross - what it is trying to protect - what it remembers +- what inputs, outputs, constraints, and receipts steer the current turn - how it is currently activated -It does not store the whole project map in personality memory. That way lies a -small cult of confused blobs. +It does not store affect, social bonds, status reads, or the whole project map +in personality memory. That way lies a small cult of confused blobs. ## Stored Shape @@ -43,11 +51,11 @@ Each record in `state/agents.msgpack` is an - `implementation` -> `epiphany.hands` - `verification` -> `epiphany.soul` -There is intentionally no `reorientation` / `epiphany.continuity` dossier. +There is intentionally no `reorientation` / `epiphany.continuity` organ-state record. Reorientation is a bounded Continuity worker/procedure, and Continuity records typed protocol receipts rather than self-memory. -The top-level shape is: +The local top-level shape is: - `schema_version` - `role_id` @@ -57,7 +65,7 @@ The top-level shape is: - `events` - `scenes` -The `agent` bundle contains: +The local `agent` bundle contains: - `agent_id` - `identity` @@ -93,28 +101,29 @@ Current activation is how hot it is right now. ## Epiphany-Specific Policy -Epiphany now treats the wire schema as one shared body shape with two explicit -profiles layered over it: +Epiphany treats local role memory as two explicit profiles: -1. `lane_core` -2. `embodied_actor` +1. `work_organ` +2. `persona` -See [dossier-profiles.md](./dossier-profiles.md). +See [organ-state-profiles.md](./organ-state-profiles.md). The important distinction is: -- most standing Epiphany organs want a lean role lattice with room to grow - through memory, rumination, and distillation -- Face and Ghostlight-style characters want a denser, more fallible, more - relationship-heavy personality surface +- Self, Imagination, Eyes, Proprioception, Hands, and Soul want a lean role + lattice with room to grow through memory, rumination, and distillation +- Epiphany Face, VoidBot repo Faces, and Ghostlight-style characters want the + denser, more fallible, relationship-heavy `Persona` surface +- Heartbeat/swarm state owns scheduling, initiative, cooldown, active-turn + freeze, and sleep/rumination physiology -So the schema stays shared, but the expected population density changes by -profile. +So the local store remains compatible with existing role memory, but the +authority split is explicit: work-organ state is not Persona state. -Epiphany does **not** currently require every standing sub-agent to populate the -full old Ghostlight trait inventory. That would be fake precision. But the -full embodied Ghostlight families remain canonical, available, and appropriate -for Face and character-grade agents. +Epiphany does **not** require every standing sub-agent to populate the full old +Ghostlight trait inventory. That would be fake precision. The dense personality +families, affect, relationship pressure, perceived overlays, and social-read +machinery belong to `persona`. ## Mutation Boundaries @@ -135,14 +144,14 @@ Canonical trait bundles currently change through two sanctioned paths: That birth-time route is documented in [repo-personality-birth-projection.md](./repo-personality-birth-projection.md). -Face and future embodied actors are still expected to evolve through richer -event, relationship, appraisal, and distillation flows. The current narrow -`selfPatch` contract is enough for lane-core growth, but it is not the end of -the story for fully embodied personalities. +Persona state is expected to evolve through richer event, relationship, +appraisal, affect, and distillation flows. The current narrow `selfPatch` +contract is enough for work-organ growth, but it is not the end of the story +for portable Personas. ## Project Truth Versus Self Truth -These dossiers are not the same thing as thread state. +These organ-state records are not the same thing as thread state. Project truth belongs in typed Epiphany state such as: @@ -153,12 +162,12 @@ Project truth belongs in typed Epiphany state such as: - evidence ledgers - runtime-spine receipts -Dossiers hold role-local durable judgment, not the whole machine's current -world model. +Organ-state records hold role-local durable judgment, not the whole machine's +current world model. ## Related Contracts - [agent-state-variable-glossary.md](./agent-state-variable-glossary.md) -- [dossier-profiles.md](./dossier-profiles.md) +- [organ-state-profiles.md](./organ-state-profiles.md) - [heartbeat-state-schema.md](./heartbeat-state-schema.md) - [repo-personality-birth-projection.md](./repo-personality-birth-projection.md) diff --git a/schemas/cultnet/README.md b/schemas/cultnet/README.md index a53e567c..4dbda3ae 100644 --- a/schemas/cultnet/README.md +++ b/schemas/cultnet/README.md @@ -6,7 +6,7 @@ surface projections, control intents, and receipt/artifact payloads that the runtime-spine advertises over `cultnet.schema.v0`. The product direction is project-native agency: clients should speak to a -project or one of its Faces, then watch typed scheduling, memory, evidence, and +project or one of its Faces/Personas, then watch typed scheduling, memory, evidence, and authority surfaces do the structuring work. Aquarium is the most direct client, but Discord, voice/WebRTC rooms, stream overlays, native CLIs, and other trusted tools should discover the same contracts instead of inventing private command @@ -32,7 +32,7 @@ server object deserves to be duplicated into a second baroque schema maze. `epiphany.agent_utterance_state.v0` for speech-conditioning without memory payloads. - `epiphany.surface.*`: operator-safe projections for scene, freshness, - context, graph query, coordinator, roles, jobs, Face, Rider, Unity, repo + context, graph query, coordinator, roles, jobs, Face/Persona, Rider, Unity, repo initialization, and related live surfaces. - `*.intent.v0`: control documents Aquarium, a Discord bridge, a voice surface, or another trusted coordinator can submit through CultNet. diff --git a/schemas/cultnet/epiphany.agent-utterance-state.schema.json b/schemas/cultnet/epiphany.agent-utterance-state.schema.json index 8bdb716a..556f2683 100644 --- a/schemas/cultnet/epiphany.agent-utterance-state.schema.json +++ b/schemas/cultnet/epiphany.agent-utterance-state.schema.json @@ -2,7 +2,7 @@ "$schema": "http://json-schema.org/draft-07/schema#", "$id": "https://gamecult.dev/epiphany/cultnet/epiphany.agent-utterance-state.schema.json", "title": "Epiphany Agent Utterance State", - "description": "Derived speech-conditioning subset of a Ghostlight agent dossier plus heartbeat mood/activation. Excludes memories.", + "description": "Derived speech-conditioning subset of Epiphany organ state plus heartbeat mood/activation. Excludes memories; portable Persona state remains a separate contract.", "type": "object", "additionalProperties": false, "properties": { @@ -18,22 +18,28 @@ "agentId": { "type": "string" }, - "dossierProfile": { + "organStateProfile": { "type": "object", "additionalProperties": false, "properties": { "profileKind": { "enum": [ - "lane_core", - "embodied_actor" + "work_organ", + "persona" ] }, - "canonicalDensity": { + "stateDensity": { + "type": "string" + }, + "portableContract": { "type": "string" }, "relationshipModel": { "type": "string" }, + "affectModel": { + "type": "string" + }, "perceivedOverlayMode": { "type": "string" }, @@ -52,8 +58,10 @@ }, "required": [ "profileKind", - "canonicalDensity", + "stateDensity", + "portableContract", "relationshipModel", + "affectModel", "perceivedOverlayMode", "growthChannels", "notes" @@ -378,7 +386,7 @@ "source", "roleId", "agentId", - "dossierProfile", + "organStateProfile", "identity", "personalityVectors", "values", diff --git a/schemas/cultnet/epiphany.agent.memory.schema.json b/schemas/cultnet/epiphany.agent.memory.schema.json index 861d0979..e2021c19 100644 --- a/schemas/cultnet/epiphany.agent.memory.schema.json +++ b/schemas/cultnet/epiphany.agent.memory.schema.json @@ -2,7 +2,7 @@ "$schema": "http://json-schema.org/draft-07/schema#", "$id": "https://gamecult.dev/epiphany/cultnet/epiphany.agent.memory.schema.json", "title": "Epiphany Agent Memory", - "description": "Ghostlight-shaped role dossier entry used by Epiphany lanes and Face.", + "description": "Local Epiphany organ memory entry. Work organs use this as lean role state; Face may project/adopt portable Persona state separately.", "type": "object", "additionalProperties": true, "properties": { diff --git a/schemas/cultnet/epiphany.work_organ_state.v0.schema.json b/schemas/cultnet/epiphany.work_organ_state.v0.schema.json new file mode 100644 index 00000000..7ffe63e1 --- /dev/null +++ b/schemas/cultnet/epiphany.work_organ_state.v0.schema.json @@ -0,0 +1,196 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "$id": "https://gamecult.dev/epiphany/cultnet/epiphany.work_organ_state.v0.schema.json", + "title": "Epiphany Work Organ State v0", + "description": "Light function-shaped state for Epiphany internal organs. This is not Persona/FaceState and does not carry full affect, social-bond, or status-read machinery.", + "type": "object", + "additionalProperties": false, + "properties": { + "schemaVersion": { + "const": "epiphany.work_organ_state.v0" + }, + "organId": { + "type": "string" + }, + "roleIdentity": { + "$ref": "#/definitions/roleIdentity" + }, + "authorityBoundary": { + "type": "string" + }, + "currentTaskContext": { + "type": "array", + "items": { + "$ref": "#/definitions/note" + }, + "default": [] + }, + "workingMemory": { + "type": "array", + "items": { + "$ref": "#/definitions/note" + }, + "default": [] + }, + "inputs": { + "type": "array", + "items": { + "$ref": "#/definitions/surface" + }, + "default": [] + }, + "outputs": { + "type": "array", + "items": { + "$ref": "#/definitions/surface" + }, + "default": [] + }, + "activeConstraints": { + "type": "array", + "items": { + "$ref": "#/definitions/note" + }, + "default": [] + }, + "receipts": { + "type": "array", + "items": { + "$ref": "#/definitions/receiptRef" + }, + "default": [] + }, + "selfImprovementNotes": { + "type": "array", + "items": { + "$ref": "#/definitions/note" + }, + "default": [] + }, + "skillCapabilityProfile": { + "type": "array", + "items": { + "$ref": "#/definitions/note" + }, + "default": [] + }, + "updatedAt": { + "type": "string" + } + }, + "required": [ + "schemaVersion", + "organId", + "roleIdentity", + "authorityBoundary", + "currentTaskContext", + "workingMemory", + "inputs", + "outputs", + "activeConstraints", + "receipts", + "selfImprovementNotes", + "skillCapabilityProfile", + "updatedAt" + ], + "definitions": { + "roleIdentity": { + "type": "object", + "additionalProperties": false, + "properties": { + "name": { + "type": "string" + }, + "organKind": { + "enum": [ + "self", + "imagination", + "eyes", + "proprioception", + "hands", + "soul" + ] + }, + "mission": { + "type": "string" + } + }, + "required": [ + "name", + "organKind", + "mission" + ] + }, + "note": { + "type": "object", + "additionalProperties": false, + "properties": { + "id": { + "type": "string" + }, + "summary": { + "type": "string" + }, + "evidenceRefs": { + "type": "array", + "items": { + "type": "string" + }, + "default": [] + }, + "status": { + "type": "string" + }, + "updatedAt": { + "type": "string" + } + }, + "required": [ + "id", + "summary", + "status", + "updatedAt" + ] + }, + "surface": { + "type": "object", + "additionalProperties": false, + "properties": { + "documentType": { + "type": "string" + }, + "authority": { + "type": "string" + }, + "summary": { + "type": "string" + } + }, + "required": [ + "documentType", + "authority", + "summary" + ] + }, + "receiptRef": { + "type": "object", + "additionalProperties": false, + "properties": { + "documentType": { + "type": "string" + }, + "receiptId": { + "type": "string" + }, + "summary": { + "type": "string" + } + }, + "required": [ + "documentType", + "receiptId", + "summary" + ] + } + } +} diff --git a/schemas/cultnet/gamecult.persona_state.v0.schema.json b/schemas/cultnet/gamecult.persona_state.v0.schema.json new file mode 100644 index 00000000..0a81c0df --- /dev/null +++ b/schemas/cultnet/gamecult.persona_state.v0.schema.json @@ -0,0 +1,415 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "$id": "https://gamecult.dev/cultnet/gamecult.persona_state.v0.schema.json", + "title": "GameCult Persona State v0", + "description": "Portable person-state contract for Epiphany Face, VoidBot repo Faces, and Ghostlight characters. Epiphany work organs should not use this unless they are acting as a public Persona.", + "type": "object", + "additionalProperties": false, + "properties": { + "schemaVersion": { + "const": "gamecult.persona_state.v0" + }, + "personaId": { + "type": "string" + }, + "publicName": { + "type": "string" + }, + "publicDescription": { + "type": "string" + }, + "privateNotes": { + "type": "array", + "items": { + "type": "string" + }, + "default": [] + }, + "values": { + "type": "array", + "items": { + "$ref": "#/definitions/value" + }, + "default": [] + }, + "activationProfile": { + "$ref": "#/definitions/activationProfile" + }, + "thoughtMemory": { + "$ref": "#/definitions/thoughtMemory" + }, + "agencyPressure": { + "$ref": "#/definitions/agencyPressure" + }, + "candidateInterventions": { + "$ref": "#/definitions/candidateInterventions" + }, + "affect": { + "$ref": "#/definitions/personaAffect" + }, + "updatedAt": { + "type": "string" + } + }, + "required": [ + "schemaVersion", + "personaId", + "publicName", + "activationProfile", + "thoughtMemory", + "agencyPressure", + "candidateInterventions", + "affect", + "updatedAt" + ], + "definitions": { + "traitVector": { + "type": "object", + "additionalProperties": false, + "properties": { + "mean": { + "type": "number", + "minimum": 0, + "maximum": 1 + }, + "plasticity": { + "type": "number", + "minimum": 0, + "maximum": 1 + }, + "currentActivation": { + "type": "number", + "minimum": 0, + "maximum": 1 + } + }, + "required": [ + "mean", + "plasticity", + "currentActivation" + ] + }, + "traitMap": { + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/traitVector" + } + }, + "activationProfile": { + "type": "object", + "additionalProperties": false, + "properties": { + "underlyingOrganization": { + "$ref": "#/definitions/traitMap" + }, + "stableDispositions": { + "$ref": "#/definitions/traitMap" + }, + "behavioralDimensions": { + "$ref": "#/definitions/traitMap" + }, + "presentationStrategy": { + "$ref": "#/definitions/traitMap" + }, + "voiceStyle": { + "$ref": "#/definitions/traitMap" + }, + "situationalState": { + "$ref": "#/definitions/traitMap" + } + }, + "required": [ + "underlyingOrganization", + "stableDispositions", + "behavioralDimensions", + "presentationStrategy", + "voiceStyle", + "situationalState" + ] + }, + "value": { + "type": "object", + "additionalProperties": false, + "properties": { + "id": { + "type": "string" + }, + "label": { + "type": "string" + }, + "priority": { + "type": "number", + "minimum": 0, + "maximum": 1 + }, + "summary": { + "type": "string" + } + }, + "required": [ + "id", + "label", + "priority" + ] + }, + "target": { + "type": "object", + "additionalProperties": false, + "properties": { + "kind": { + "type": "string" + }, + "id": { + "type": "string" + }, + "label": { + "type": "string" + } + }, + "required": [ + "kind", + "id" + ] + }, + "anchoredThought": { + "type": "object", + "additionalProperties": true, + "properties": { + "id": { + "type": "string" + }, + "status": { + "type": "string" + }, + "target": { + "$ref": "#/definitions/target" + }, + "summary": { + "type": "string" + }, + "claim": { + "type": "string" + }, + "question": { + "type": "string" + }, + "tension": { + "type": "string" + }, + "actionImplication": { + "type": "string" + }, + "intensity": { + "type": "number", + "minimum": 0, + "maximum": 1 + }, + "valence": { + "type": "number", + "minimum": -1, + "maximum": 1 + }, + "createdAt": { + "type": "string" + }, + "updatedAt": { + "type": "string" + }, + "retiredAt": { + "type": "string" + }, + "tags": { + "type": "array", + "items": { + "type": "string" + } + } + }, + "required": [ + "id", + "status", + "target", + "summary", + "tension", + "actionImplication", + "createdAt", + "updatedAt" + ] + }, + "thoughtMemory": { + "type": "object", + "additionalProperties": false, + "properties": { + "shortTerm": { + "type": "array", + "items": { + "$ref": "#/definitions/anchoredThought" + }, + "default": [] + }, + "memories": { + "type": "array", + "items": { + "$ref": "#/definitions/anchoredThought" + }, + "default": [] + }, + "incubation": { + "type": "array", + "items": { + "$ref": "#/definitions/anchoredThought" + }, + "default": [] + } + }, + "required": [ + "shortTerm", + "memories", + "incubation" + ] + }, + "agencyPressure": { + "type": "object", + "additionalProperties": false, + "properties": { + "pressures": { + "type": "array", + "items": { + "$ref": "#/definitions/anchoredThought" + }, + "default": [] + } + }, + "required": [ + "pressures" + ] + }, + "candidateInterventions": { + "type": "object", + "additionalProperties": false, + "properties": { + "interventions": { + "type": "array", + "items": { + "$ref": "#/definitions/anchoredThought" + }, + "default": [] + } + }, + "required": [ + "interventions" + ] + }, + "moodDimension": { + "type": "object", + "additionalProperties": false, + "properties": { + "name": { + "type": "string" + }, + "value": { + "type": "number", + "minimum": 0, + "maximum": 1 + }, + "source": { + "type": "string" + }, + "updatedAt": { + "type": "string" + } + }, + "required": [ + "name", + "value", + "updatedAt" + ] + }, + "socialBias": { + "type": "object", + "additionalProperties": false, + "properties": { + "name": { + "type": "string" + }, + "value": { + "type": "number", + "minimum": 0, + "maximum": 1 + }, + "summary": { + "type": "string" + }, + "behavioralPull": { + "type": "string" + }, + "updatedAt": { + "type": "string" + } + }, + "required": [ + "name", + "value", + "summary", + "behavioralPull", + "updatedAt" + ] + }, + "personaAffect": { + "type": "object", + "additionalProperties": false, + "properties": { + "needs": { + "type": "array", + "items": { + "$ref": "#/definitions/anchoredThought" + }, + "default": [] + }, + "socialBonds": { + "type": "array", + "items": { + "$ref": "#/definitions/anchoredThought" + }, + "default": [] + }, + "statusReads": { + "type": "array", + "items": { + "$ref": "#/definitions/anchoredThought" + }, + "default": [] + }, + "moodDimensions": { + "type": "array", + "items": { + "$ref": "#/definitions/moodDimension" + }, + "default": [] + }, + "socialBiases": { + "type": "array", + "items": { + "$ref": "#/definitions/socialBias" + }, + "default": [] + }, + "doctrineStances": { + "type": "array", + "items": { + "$ref": "#/definitions/anchoredThought" + }, + "default": [] + } + }, + "required": [ + "needs", + "socialBonds", + "statusReads", + "moodDimensions", + "socialBiases", + "doctrineStances" + ] + } + } +} diff --git a/schemas/cultnet/index.json b/schemas/cultnet/index.json index f6f9d965..82d08f68 100644 --- a/schemas/cultnet/index.json +++ b/schemas/cultnet/index.json @@ -210,6 +210,28 @@ "title": "Epiphany Agent Utterance State", "path": "epiphany.agent-utterance-state.schema.json" }, + { + "schemaId": "https://gamecult.dev/cultnet/gamecult.persona_state.v0.schema.json", + "kind": "document_payload", + "wireContracts": [ + "cultnet.schema.v0" + ], + "schemaVersion": "gamecult.persona_state.v0", + "documentType": "gamecult.persona_state.v0", + "title": "GameCult Persona State v0", + "path": "gamecult.persona_state.v0.schema.json" + }, + { + "schemaId": "https://gamecult.dev/epiphany/cultnet/epiphany.work_organ_state.v0.schema.json", + "kind": "document_payload", + "wireContracts": [ + "cultnet.schema.v0" + ], + "schemaVersion": "epiphany.work_organ_state.v0", + "documentType": "epiphany.work_organ_state.v0", + "title": "Epiphany Work Organ State v0", + "path": "epiphany.work_organ_state.v0.schema.json" + }, { "schemaId": "https://gamecult.dev/epiphany/cultnet/epiphany.agent-heartbeat.schema.json", "kind": "document_payload", diff --git a/schemas/dossier-profiles.md b/schemas/dossier-profiles.md deleted file mode 100644 index 482f5ab7..00000000 --- a/schemas/dossier-profiles.md +++ /dev/null @@ -1,112 +0,0 @@ -# Dossier Profiles - -Epiphany uses one Ghostlight-shaped storage schema with two explicit operating -profiles. - -This split exists because "what makes a coding organ effective" and "what makes -a public-facing or dramatic personality feel embodied and fallible" are not the -same problem, even if they share a skeleton. - -## Profiles - -### `lane_core` - -Intended for: - -- Self -- Imagination -- Eyes -- Body -- Hands -- Soul - -These organs need: - -- sharp role identity -- stable working values -- durable mission-relevant memory -- enough personality texture to steer rumination, timing, and self-modification -- resistance to personality sludge and faux-human overfitting - -They do **not** need every old Ghostlight trait slot populated just to cosplay -depth. - -Recommended shape: - -- one standing canonical trait per family minimum -- goals, values, semantic memory, and private notes always present -- relationship and perceived-overlay surfaces optional and narrow -- self-modification primarily through: - - reviewed `selfPatch` - - heartbeat rumination pressure - - sleep/distillation - - birth-time repo personality/memory seeding - -Failure mode if overbuilt: - -- the organ becomes theatrical instead of useful -- working memory fills with fake interiority instead of sharper judgment -- every lane starts behaving like a roleplay goblet with a compiler strapped to it - -### `embodied_actor` - -Intended for: - -- Face -- future multiple Faces or perspective-mouths (for example faction-facing - Aetheria interlocutors) -- Ghostlight scene characters -- any future public, social, or dramatic agent that must react as a situated - person rather than a narrow work organ - -These agents need: - -- denser canonical personality surfaces -- relationship pressure -- perceived-state fallibility -- episodic accumulation that actually colors reaction -- response shaped by appraisal, not just policy -- room to misread, overread, hesitate, overcompensate, or project - -Recommended shape: - -- dense Ghostlight family maps using the canonical label inventory -- active use of `relationship_summaries` -- meaningful `perceived_state_overlays` -- character-loop interpretation and reaction as first-class behavior -- growth through: - - events - - relationships - - appraisal/reaction cycles - - reviewed self-memory mutation - - sleep/distillation - -Failure mode if underbuilt: - -- Face becomes a status printer with eyeliner -- Ghostlight characters become omniscient utility daemons wearing skin - -## Current State - -Right now the storage schema supports both profiles, but the live standing -Epiphany role shells are still mostly sparse. That is acceptable for the lane -organs and a current limitation for Face. - -So the policy is: - -- sparse lane-core dossiers are fine when they improve work -- Face should trend toward embodied-actor richness -- the current singular `face` role is an MVP constraint, not a metaphysical law -- do not pretend those are the same requirement - -## Wire Visibility - -The distinction should be visible to tools, not hidden in a footnote. - -Current typed surfaces expose dossier profile classification through: - -- `epiphany-agent-memory-store status` -- `epiphany-character-loop` packets - -If a future surface consumes role dossiers without surfacing profile kind, it is -already drifting back toward folklore. diff --git a/schemas/ghostlight.agent-state.schema.json b/schemas/ghostlight.agent-state.schema.json index b50fd201..936e9657 100644 --- a/schemas/ghostlight.agent-state.schema.json +++ b/schemas/ghostlight.agent-state.schema.json @@ -2,7 +2,7 @@ "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://github.com/GameCult/Epiphany/blob/main/schemas/ghostlight.agent-state.schema.json", "title": "Epiphany Ghostlight Agent State Schema", - "description": "Canonical Epiphany-owned Ghostlight-shaped contract for agent, perception, relationship, event, scene, and dialogue-context state.", + "description": "Source-lineage Ghostlight contract for dense character agent, perception, relationship, event, scene, and dialogue-context state.", "type": "object", "required": [ "schema_version", diff --git a/schemas/heartbeat-state-schema.md b/schemas/heartbeat-state-schema.md index 7d31fb6d..d43037a3 100644 --- a/schemas/heartbeat-state-schema.md +++ b/schemas/heartbeat-state-schema.md @@ -106,16 +106,16 @@ The important semantics are: - saturation and refractory cooling exist to keep one rewarding theme from annexing the whole machine -## Relation To Agent Dossiers +## Relation To Organ State Heartbeat is physiology, not identity. -Role dossiers describe what an organ is. Heartbeat describes how often it gets +Organ-state records describe what an organ is. Heartbeat describes how often it gets the floor, how reactive it is, and how current pressure bends that timing. Current emotional state is heartbeat physiology. Appraisals write a bounded named affect vector into `mood_timing`; utterance state consumes that live vector -before falling back to slower dossier traits. If anger, despair, annoyance, +before falling back to slower organ-state traits. If anger, despair, annoyance, dismissal, flippancy, or any other speech-relevant feeling is meant to color a voice, it must exist here or in the typed appraisal feeding this field, not only as prose in a prompt. diff --git a/schemas/organ-state-profiles.md b/schemas/organ-state-profiles.md new file mode 100644 index 00000000..9ffbd258 --- /dev/null +++ b/schemas/organ-state-profiles.md @@ -0,0 +1,120 @@ +# Organ State Profiles + +Epiphany uses one local `state/agents.msgpack` store, but it does not use one +personality ontology for every organ. That was the old mush vector. + +The live profile split is: + +- `work_organ`: lean state for resident Epiphany sub-agents. +- `persona`: portable person-state for Epiphany Face, VoidBot repo Faces, and + Ghostlight characters. + +`Face` is the Epiphany organ. `Persona` is the cross-runtime state contract. +VoidBot's older "FaceState" phrasing maps to `persona` here. + +Swarm state is separate again: heartbeat, scheduler, initiative, cooldown, +active-turn freeze, lane coordination, and sleep/rumination physiology live in +heartbeat/swarm contracts rather than either local work-organ state or Persona +state. + +## `work_organ` + +Intended for: + +- Self +- Imagination +- Eyes +- Proprioception +- Hands +- Soul + +Work organs need: + +- identity and role boundary +- authority boundary +- current task/context +- durable mission-relevant memory +- inputs and outputs +- active constraints +- receipts +- values and goals that steer judgment +- heartbeat activation and timing pressure +- narrow private notes for future self-correction +- optional skill/capability profile + +They do not need affect, social-bond machinery, dramatic relationship stance, +or dense Ghostlight personality maps unless a real use case earns that weight. + +Recommended shape: + +- `identity` +- `goals` +- `canonical_state.values` +- authority/input/output/receipt summaries when projected onto CultNet +- sparse trait maps only where they steer work +- semantic and episodic memories when they change future judgment +- relationship summaries only when they describe organ dependency or working + coordination + +The portable light schema is +[`epiphany.work_organ_state.v0`](./cultnet/epiphany.work_organ_state.v0.schema.json). + +Forbidden sludge: + +- treating mood as proof +- storing repo truth in self-memory +- giving Hands, Eyes, Soul, or Proprioception Face-style attention hunger, + status reads, social bonds, or performative personality loops + +## `persona` + +Intended for: + +- Epiphany Face +- VoidBot repo Faces +- Ghostlight scene characters +- future public or dramatic agents that must react as situated people + +Persona state needs: + +- public identity +- values and private notes +- activation/personality vectors +- voice and presentation constraints +- thought memory +- agency pressure +- candidate interventions +- affect: needs, social bonds, status reads, mood dimensions, social biases, + and doctrine stances +- perceived-state overlays or equivalent fallible social/world reads + +The portable schema is +[`gamecult.persona_state.v0`](./cultnet/gamecult.persona_state.v0.schema.json). +It is deliberately close to VoidBot's mature repo Face state while remaining +usable by Ghostlight and Epiphany Face. + +Failure mode if underbuilt: + +- Face becomes a status printer with eyeliner +- Ghostlight characters become omniscient utility daemons wearing skin + +Failure mode if over-applied: + +- every Epiphany work lane starts growing fake interiority instead of sharper + judgment + +## Wire Visibility + +The distinction is visible to tools through `organStateProfile`: + +- `profileKind = work_organ` +- `profileKind = persona` + +Current typed surfaces expose profile classification through: + +- `epiphany-agent-memory-store status` +- `epiphany-character-loop` packets +- `epiphany.agent_utterance_state.v0` + +If a surface consumes local organ state without surfacing the profile kind, it +is already drifting back toward folklore. diff --git a/schemas/repo-personality-birth-projection.md b/schemas/repo-personality-birth-projection.md index 3f299578..20be4f91 100644 --- a/schemas/repo-personality-birth-projection.md +++ b/schemas/repo-personality-birth-projection.md @@ -100,7 +100,7 @@ Current sanctioned routes are: ## Related Stores -- canonical dossiers: `state/agents.msgpack` +- canonical organ state: `state/agents.msgpack` - heartbeat physiology: `state/agent-heartbeats.msgpack` - initialization receipts: `state/repo-initialization.msgpack` diff --git a/state/agents.msgpack b/state/agents.msgpack index 28e03812c1c5e09fa9ea0f1e9d22368b88ccaaa2..70cf29ff30c37965a82c359c75d86e55db8b2aca 100644 GIT binary patch delta 4544 zcma)AeQ;FO6>n^d5Mz)bgoco?Y(mHycL@nN5X7A-1fdw9U|Ol=_3qpIc3<=My~q1V zh>peADebg%BCG~5-&cQeCx`OkW(Val57KgK2aCPOm`d>roj&UYWrGIv8m z&2?iP?HzYV+m}W=mTzfq?`rStYG1zfjcPp)Petb3eo)jjBPpu{Pm+T(ky`jL(mW%3 z*tCd>k5eJ^sTqT?y>lbfRD5sNo|mXD>uI76#!RY6!y}vV8xB;=hj%OHz~>cDjQ;eN zY{lZdbIj0e3mpha*%W16kyQ$X_}}$sKd4-}y%0a!`q^u{ABhy=SI@G~JMh9+>US~& zeA@cicp?7wUiR6CPa02dy0UAYbKIc)G93_7#G-<%S~O+I)*vqVSaLsw_?wk0nS1WU z86%>FF%k?)O#EfaDU~R=;%cz@yUcat$wHicZ%SO*<%}kcK|HcSMN80hYOuKAipv+) z9IAQrLLtsqTz2Xt0ZW`?=$1ban@C~y$I6S2pic=n}D#ZWc zopwBzhs3QB$loefk0`Q4aWl^~ES!4(w4np+4*fI_Kc5U36M&60w$!R?$MxRe> zgO18vVB}vEKCRpw;+{^VG@?XV_M$9DG-^>*O_<5GFZd1;O3rK7F8L}N>l%P_nuezec?=P z-CSl6K#ya?hZZcF-M|d|&==ybd)MSqfoEpdu?pbf*;Kp=1}t>0^Ri~I8lFJ zr3ZHydO8QOxy_?n=gzK(aikfN}xEfw>c(bD87ZQgQUB`jpT^NfjyxV_7i97OjG8Y_+Ui33;=z}CEEv_BMBn*DOyU<4QiTrV+LlX53lVm#Lovx z;WH7Eg|?s>_AcmTc=HI1;caTm0$AR%Bfy(4F!0BgH6_%Bi=~BauyV018GL@I6uhR5%eYxf-DU_eYK&Ee-Bz+X_;7KZ!U8o+21 z;V*6LcjlcFre+%=6)epb(=0eBJlF8g*??!RFbR701Lx>O!gSj(ZP~(Layfp>)xmFa z^f)ghWl0h&!?s*H2$G5^QdySx^_?*@LlgximWeY-C{z$_=Gx!)28wx9SBR_%q6-^U zv#5#Ymjb!xu<_Fhn_{yX(SVC8hqVt*%+AZPX1EahR(am7MPb;#$PV)EqaIeZFDuXc z>GmeL*gkS&`8mIM9{hK)5W@Yh38+g9&u6qG#nvV@xdct=b(x`(n|?78&PDdT%u%2l znr_IN$a)J+9X_~9!Y(g43$($rS`Vfl-Ydnz-u+V9jBnjzLN8Lauauw+G}WN4X? z2cc*RTL4y*ALz*byINo&jEw!6hg;-f8(+!A^^HkQrGdN*Nw`C-A$V zf%4<%9K}xCqzNivS080Zj4f+i zT1rO6g>LV4%{mP60Lm9?67~_85u&Hz*s_%5w}U=%i+8V;Lf0f(k*RrCh_Qqj!m=|% zRvPn}N{2{DwKItjo*_2Tzv02#nFf|`53eq7yruX{`0Mf=!Zq%F9LXyBr6EsrVkM=> zrM1{}z2B(IVNsRRWE6#2R*FA?kGeXm%lCk}E4q~X4qQtOH z1+^3kEEc&IA=UxHfo>JTYc#ByQCyKBI70Y1O~{0?8z(Q$ZhY7njLHrh%0-?6mK2?hhsHV`5QslYk3NTSX-e7}_9a>ipUtib57~7lP zm{J$;;Xl{?AYg1?oZwgA=#7+u_!Pq$OIkEROQyAy*-o7&tLtU3p#kB=k}Xw`{oU+N(T#shJtf5e#6@v z>fy?UCYZmm7j|vDmmq*7qL{LTMCwkil5Du-#qV?7SbP+(osrG|b0mgSo7^6d1Cpmc z=o4NPH6@8T$1aV!6HP#^?|4ljuT|%Wt(r7xi)iYpKZ4LlT*-Xz$JIG3tNl1CAl#ez zl)=@3cYc2NhzMD?xe?UOYww(xC$jm|-sFmr!`7dLX%HdclC4fm6B@Q$H^3IRbd{_9 imWP^P=R-ecY9IW!0fz|m^ftj@uZC#g@$n^wq2Yi0W+2%B delta 6472 zcmbVQYj9N69d9V)MFbKcfxOscLkz(Uo6Q3VuYeX|My-g&%GBQ8y?b`|Gw)ApN*QjiY)TTw5F1Sx`|U*Bact3oqODH;wo08 z1hNzp8#dN8^4zqa&3eNy@t|xYNz-j)jW782z9RC$vi1j#o4R9TEhQzerC>wF8hTsd{^GhzZC{?-`-3IN6~{E`N@c~SWnq?!>#kp-Kkt$I zqw~qf(`#o>)`1aiU%o?jMca!TPi?ujXAv2T){v?h)x+W|HU3YiDrXt_(T->{dt?BTfjuiwo zvMSm&o-ng;ASP05NjDIb)lD&e;?uj2%zN}x5{fQqpI|FoGiG7iVQY|8r~r%DbySr# zs5XG$1{7>%NKvf5?7JT8c+iIgV8F?-}=!W3kwr{Xc&tr9%arxNa6^Ff-`B{HGM{D%+Y@bZ=RWzv#iT zy#rTX?vEE3uClc*_uyaLUcXwZBZ2SI^q^uwk?X8}E{IwoK8Ho|9I^2#e$6}ys0?y3xv+GX=dy7D)93P;MSo~Hsg|3t=7 zZ7eZ9%C=2)6eO`IwxWceGS#b9Z<)HDku)IjAd)~wG)rZK7OeNGhR{Mm=dYvH#atAq zu2syf&*_?rOP{X&-aWKHUE>#2K-b=~(zndc zAM$myzSE~}Cx&D*BMl*JCM2xc$fV~jY6y9o6I-&iu)LkL)4G#N+fYTe)5w&DDEdT= zpu>8fLj?|NfqPg72W8bk*3-KWv0o@N|2}u25XG{J7?Vmz7-j3NSiM z-dxa_8~gr(@hXoR2ch9iCud->DZ15 zCYzQGMB|H%RhP8+>?Yr>uMG=u3Jvt88Xh&sGtsVwH$YLr_vJWN!Bxd54rwwGZLfFX z8_ZF1tiEP4_y~D~s4&dA=_BHJTz9ktN=SxoS=c`z=bleFIHLoV<0?xfn*yT9vAC=Z zJfi9;iKZnBj!bN7g66Vwdwp|!;3liUIk-7;;_mZM?yiQ(G?Q-V@=?xJKt{P&8W#I0 zcd21#0m|`!H-&N!G~Nw{zMhOWF3sWka^rq4C-_(&C%AhN>T=md;oR6?FT!3<2>C0_ ziMmiLaH7iP#1Wh^RFok@kw1||O}Hz^i6fJofE1sw^4KuCiGIjTYcyuQ{1FS{=bEe5iTe%;^nYN%>4Cue76JjT zHvC!wCzIfej-8WvSJHj(xfMh?1%ipQ>x7k&RTVNj4KPgJ6({Fx#e7RZr5;WVAC<;{ z&RCNaQ%>4$iz7CD^;h)gd79TdIDi94G7d7XC&1J+U?Zmqobwj)dUz7qm%|SgLUvb6 zvme>tYjFx7o9oXMWdEgQ1w(fIVh=jkEgtbATWFWhFreq6T~}pKnEY$;q8zfTTP5;Y zPe_~`WV8Y*|5R&e`uWm7Q$*L1Pg+Y^JNm@!y92XXTu)^4z&x@6KI57mZEKj+^n2UF z;edAZO7_7t3ehp40fY>T9B5m$*3unQL6H=6qf`+?NTc~81ZE%7X}}24{APu0Jp>T6 z><)iBOTK7}PZhirTkuAM$SJvZ^s9jg$dHhxjO^9W8}S@^N(KuHMy|Q$3G6ZmR(F;AJbqD(=Q}Yn$RY-F(@lX;T zX40gndqeC>EA7$TebaXVw@JfR#4ziUH=oT3#Rf5GVeKKCnmJHJLnsk}!^P_4Y(FKB-O)9j&PLAOvC*qEqLuI}jqt|8 zO0qDr7?k8P^TzQVk&~qb6sNTp6sK%0{a%=(BuGRp?NYqZXwxJ($J|;z)QC7Olgz|G+V>`bPK4!coN$%F~tmh*@Aeg z=3<;nY`+h?ni8ltSJ~xW_X)xACPjsHO7O7c(1{FaG{p|N7*Gf8yIMGAI@*Ay4{4S( zh#}18mM7B4L^N78RT{{dm35+9`)K8TK7(~11zB|L?5pz|>^*&t7cf|!a;6$=-!^8j zeXAOBCi&2+H@&bIHsOVRE;@!u)9Qt}v3;vm?^vOk-m%|InKP^5Ex7aoqfF`RgUG~5 ztgs&I%$mC%4B`a9Rn2!`5Kommu&BX0t%Giy8fCfdAb%!~t_=rrW$W5)`CNH*?OMu} z@OV;IExIyRRZ3zr=N0_SywAJfnp?&|;=od%ONS?h6n&u-c=|sdd#Sh9o`#YZeXfR> z$e!oCX{~-6f07A=J;z}Ig1xTjY65@{@egTYrK0OQ-nnE`Py=_&(JYj36d2_mv>3?m z-A768&GbDc9FRbdVr@`1F=&nZm_j2*&#mG#?=Axe>GP^?9{>eIKLLqw77H^@a6Ml55=|@zhT{t`!@abF|sMLHE*zTbAF(c$zBcH2(!C C)aq>j diff --git a/state/ledgers.msgpack b/state/ledgers.msgpack index 2301ba365dd814c33e15a0b0853991f1ae15493a..cc385586ab71adfd63dd01f9af565087a7c59056 100644 GIT binary patch delta 817 zcmZ{iyNVP+6o%~%HxfkS1ExEdZSb-)7^tY(Ixu2jvYf6u-CfvSr>&~qVWMFX5hD`^ zUqdhuU%(CJth8t+vILvE;1sTg4`@b1HYE@gIUc-vb%f8Km<`vk^6ey^FT82Rj!-cBp zUZ_0n7p#=4d^IdK!&EE^5^iEyD6gVHQ7KJkJ%`6()-cmTJCw)%owO1g5?$@a!}n>_ zKR%m6!Dgp)@|=}?z;5!SV(V&ERt{999T{%t(6FRh>2mPCLJNY8@uEofBxrCv&RMR( zG3*{%Kfx##)H=m_{4ed8&IN5ZsMzr=J0($jlVPROeyR86smU3*ia@gH8uBV7*qD>* zF+UAKMZD2uZ>Q+A2ogrN!q#_O%H}XE+=K-8O@Zwt8W(_|?ebcQ0k%B^)Do5}G|j%% zii%`clbKY6#^r?0^I{{F#s~rKOX(Ht7{&0{G5vi!IawtM{-2*^$l0HYCmc@5uh7n* ia2C*bHp&VB#G$zk?HU5Ck>|0v*;|j{gGdSS!i^ delta 41 xcmaDimFq%3*9Kw6>ATvPxY(kOF)+2Q-K@-5$jJD(c`8%;R3^slQ<<2oTLDFR4sQSe diff --git a/state/map.yaml b/state/map.yaml index a92154a6..9780b6dd 100644 --- a/state/map.yaml +++ b/state/map.yaml @@ -74,13 +74,14 @@ active_subgoals: - CultMesh is now the preferred ergonomic Rust abstraction over CultCache and CultNet for Epiphany-owned local database surfaces. The Rust substrate is repo-contained under `vendor/cultcache-rs`, `vendor/cultnet-rs`, and `vendor/cultmesh-rs`; the old `E:\Projects\CultLib\crates\*` path is dead in this checkout and must not be reintroduced as a compile-time dependency. Future local Verse/dream/status work should start at CultMesh unless it is explicitly polishing CultMesh internals. Preserve the three-Verse boundary: `epiphany-internal` for private sub-agent typed state, `gamecult-local` for trusted LAN/Yggdrasil-tunnel GameCult project sharing, and `epiphany-global` for untrusted public dreams plus topic-specific threaded public rooms for Face posts. - The active priority is Codex starvation and CultNet liberation. Use `notes/codex-starvation-and-cultnet-liberation-plan.md` as the directive and `notes/codex-auth-spine-inventory.md` as the source-grounded keeper list for the retained OpenAI subscription auth/model transport bridge. Classify all Epiphany-relevant JSON contamination, define the native CultNet runtime boundary, keep worker launch/result/selfPatch cargo as typed documents, evacuate Epiphany operator/state/process authority from Codex JSON-RPC, wrap MCP's unavoidable JSON protocol edge in typed Epiphany intent/result/receipt documents, and keep cutting until Epiphany can run its own state and processes without `codex_message_processor.rs` except for bridge compatibility. - Use `notes/epiphany-anatomy.md` as the canonical anatomy map. Embodied sub-agents are Self, Face, Imagination, Eyes, Proprioception, Hands, and Soul. Body is substrate, Mind is persistent state/state admission, Continuity is recovery/compaction/sleep protocol machinery, and Substrate Gate is substrate access protocol. + - Organ state now has a hard profile split: resident Epiphany sub-agents use lean `work_organ` state, public/person-shaped agents use portable `persona` state, and heartbeat/swarm machinery owns scheduling/coordination physiology. Face is the Epiphany organ; Persona is the shared GameCult contract for Epiphany Face, VoidBot repo Faces, and Ghostlight characters. Work organs must not inherit Persona affect/social-bond/status-read machinery just because the old Ghostlight-derived shape had room for it. - The next Codex-starvation slice is the Eyes/source-gathering fork exposed by the Mom-ready MVP proof. The quarantined Codex MCP spine may execute typed tool intents and emit typed receipts; the model runtime can build and run provider-neutral follow-up turns from those receipts; coordinator run mode passes the quarantined tool adapter into worker runtime with auto-tools enabled by default; worker runtime now enforces max-runtime with one timeout close primitive for both tokio timeout and watchdog paths; inner `openai-worker-*` jobs are opened before async auth/stream waits and sealed with their outer worker on timeout; native status/roles/jobs/coordinator surfaces project failed and completed runtime-linked jobs as terminal without Codex prompt or scheduler authority; direct tiny model-turn transport succeeds; worker requests record request metrics, transport readiness, and sampled raw Responses frame kinds; worker prompts no longer prepend the full shared persistent-memory rite; stream deltas compact before durable storage; live MVP modeling workers complete instead of timing out; stale completed runtime links no longer block replacement launches; jobLaunch validates before opening runtime jobs; and completed-but-unreviewable modeling findings now stop for review instead of relaunching the same blind lane. The remaining blocker is structural: the MVP coordinator has no executable Eyes/source-gather lane, so a modeler that returns `regather-needed` cannot inspect the missing source itself. - The May 2026 teardown/rebuild migration is archived under `notes/archive/epiphany-ideal-architecture-rebuild-plan.md` unless a concrete regression reopens it. Preserve the new foundation: Epiphany view/coordinator policy lives in `epiphany-core`, runtime-spine owns job/result lifecycle identity through `runtime_links`, duplicate acceptance is receipt-keyed, public findings stay typed/sealed, view expansion requires a core contract, and app-server remains routing/adaptation rather than a second policy throne. - Treat Phase 5 update/distill/propose/promote/read/notification as complete enough unless a concrete regression appears. - Preserve read-only boundaries for retrieve, distill, propose, freshness, context, graphQuery, roleResult, reorientResult, and the canonical view lenses for scene, jobs, roles, planning, pressure, reorient, crrc, and coordinator. - Use `notes/epiphany-memory-graph-unified-plan.md` as the source-grounded memory architecture direction. The repo fractal dataflow graph and agent memory are one `EpiphanyMemoryGraph` substrate with repo, role, short-term, incubation, agency, candidate-intervention, and evidence profiles. Qdrant stores rebuildable semantic embeddings for typed graph documents; it is never canonical memory. The first live skeleton now exists in `epiphany-state-model` plus `epiphany-core::memory_graph`: typed graph documents, stable ids, profile/lifecycle validation, freshness propagation, context cuts, a CultCache store seam, and the native `epiphany-memory-graph` status/validate/context/smoke CLI. Do not add repo scanners, sleep runners, Qdrant cache plumbing, CultNet advertisement, or prompt integration before routing them through this shared substrate. - Keep the landed Phase 6 coordinator, limited safe-boundary CRRC automation, and pre-compaction checkpoint intervention ready for the next bridge-equipped dogfood run. - - Preserve the Ghostlight-derived heartbeat initiative seam: every lane, including coordinator/Self and Face, has a role dossier and competes for heartbeat slots through readiness/reaction timing; initiative heat can raise or cool global, group, arena, role, and agent tempo through typed heartbeat policy; active thinking freezes initiative until completion, so heat never queues a lane already mid-turn; idle winners ruminate instead of inventing project work, and sleep windows distill the accumulated thought pressure into reviewed self-memory or doctrine. + - Preserve the Ghostlight-derived heartbeat initiative seam: every lane, including coordinator/Self and Face, has a organ-state record and competes for heartbeat slots through readiness/reaction timing; initiative heat can raise or cool global, group, arena, role, and agent tempo through typed heartbeat policy; active thinking freezes initiative until completion, so heat never queues a lane already mid-turn; idle winners ruminate instead of inventing project work, and sleep windows distill the accumulated thought pressure into reviewed self-memory or doctrine. - Use `notes/epiphany-swarm-readiness-plan.md` as the live-fire direction gate. The local run path is a compass, not launch clearance: before unattended swarm operation, Epiphany needs a typed pause/brake, one initiative scheduler, completion-gated cooldown, stale active-turn recovery receipts, parent-side Face speech eligibility, memory lifecycle operations, and CultNet-first operator snapshots/intents/receipts. - 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. @@ -93,8 +94,8 @@ active_subgoals: - 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 sub-agent dependency. Every sub-agent depends on the other standing sub-agents: Self, Face, Imagination, Eyes, Proprioception, Hands, and Soul. Continuity is protocol machinery, not a sub-agent identity; it still emits recovery, compaction, sleep, stale-turn, and refusal receipts. - Use `notes/perfect-machine-audit-roadmap.md` as the current audit and path from named organ contracts to the Perfect Machine. It records the live gap between launch-carried receipt expectations and executable receipt enforcement, Void's latest Face prompting lessons, the now-named Hands/Soul/Continuity contract families, the repaired repo-contained Rust dependency body, and the phase order for turning Epiphany into an inspectable organism. - - Treat Ghostlight as reference lineage, not a sibling runtime to preserve. The useful organ is Epiphany-native character-loop protocol: any role can project its typed dossier plus visible stimulus into a local turn packet, with Face as the first public-surface actor. For Face, narrative prompting is mandatory through Imagination Projector -> Face -> Mind Interpreter; for other organs, Mind still owns the output-to-state gateway even when they do not need narrative embodiment. - - Treat VoidBot as reference lineage, not a runtime dependency. The useful organ is Epiphany-native Void routine physiology: heartbeat state owns sleep cycle, memory resonance, incubation, analytic/associative cognition lanes, bridge judgment, candidate interventions, dream residue, and Aquarium-visible routine receipts over typed role dossiers. + - 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 organ-state record 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 organ-state records. - Preserve review gates for semantic findings; automatic CRRC may compact or launch the fixed reorient-worker, but not accept or promote. - Keep persistent project state ruthlessly distilled so rehydration strengthens the next awakening instead of drowning it in vellum. - Until Epiphany owns the full sleep consolidator, manual Codex-run rumination vigils need an explicit closing distillation pass: inspect receipts, decide whether the lesson is durable, update only the persistent surfaces that deserve it, and record evidence only when future behavior should change. @@ -105,7 +106,7 @@ active_subgoals: - Rider and Unity bridge work is quarantined for now. The landed artifacts remain useful optional environment evidence for later engine-repo dogfood, but they are not essential to the MVP and must not outrank Codex starvation, native Epiphany state/process ownership, or prompt-authority separation. - Preserve the newly landed GUI Planning view, explicit Objective Draft adoption action, and Imagination planning synthesis lane; defer GitHub Issues import until a backlog source is fresh enough to be worth feeding Imagination. - The three-surface Rider/Aquarium/Unity workflow remains a later product option, not the current blocker. Use archived `notes/archive/epiphany-rider-unity-integration-plan.md` only when explicitly resuming engine bridge work. - - Use `notes/repo-personality-projection-layer-plan.md` as the terrain-reduced plan for repo initialization personality projection: score repo body taxonomy, commit-history temperament, and memory doctrine, then project those pressures into role-specific Ghostlight-shaped dossiers and heartbeat seeds through reviewable typed artifacts. + - Use `notes/repo-personality-projection-layer-plan.md` as the terrain-reduced plan for repo initialization personality projection: score repo body taxonomy, commit-history temperament, and memory doctrine, then project those pressures into role-specific organ-state records and heartbeat seeds through reviewable typed artifacts. - Keep repo trajectory initialization birth-only and review-gated: startup may distill historical direction, self-image, implicit goals, and anti-goals into role-local pressure, but it must not auto-adopt work or keep repainting a living repo with its first silhouette. accepted_design: @@ -121,7 +122,7 @@ accepted_design: - `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. - `epiphany-openai-runtime` worker result ingress now parses assistant output directly into launch-kind-specific typed documents and stores typed nested `statePatch` / `selfPatch` payloads as MessagePack inside `EpiphanyRuntimeRoleWorkerResult`; generic `serde_json::Value` no longer mediates role/reorient worker results in that crate. JSON still exists at the OpenAI text edge because the model's output is text, but the runtime boundary after parsing is typed. - Agent self-memory review/application now has typed `AgentSelfPatch` core APIs. The old JSON-value selfPatch functions remain only as edge compatibility wrappers for CLI/artifact ingress; `epiphany-agent-memory-store`, heartbeat rumination application, and repo initialization selfPatch processing parse once at the edge and then operate on typed documents. Role-result self-persistence no longer exports a JSON-value reviewer; native review uses `review_role_self_patch_document`. - - Durable Ghostlight role dossiers are typed through their relationship/event/scene/perceived-overlay surfaces now. `EpiphanyAgentMemoryEntry` no longer stores those arrays as `serde_json::Value`, and durable Ghostlight structs no longer carry flattened unknown `extra` bags. `AgentSelfPatch.extra` remains only as an ingress guard so unknown patch keys can be rejected with reasons. + - Durable Ghostlight organ-state records are typed through their relationship/event/scene/perceived-overlay surfaces now. `EpiphanyAgentMemoryEntry` no longer stores those arrays as `serde_json::Value`, and durable Ghostlight structs no longer carry flattened unknown `extra` bags. `AgentSelfPatch.extra` remains only as an ingress guard so unknown patch keys can be rejected with reasons. - The state ledger CultCache document is now a closed typed ledger shape. Branch and evidence records no longer carry flattened `extra` maps; evidence additions remain explicit records with `ts`, `type`, `status`, `note`, and optional branch. - Heartbeat durable document/schema types live in `epiphany-core/src/heartbeat_state/heartbeat_documents.rs`; role/default construction lives in `epiphany-core/src/heartbeat_state/heartbeat_roles.rs`; heartbeat persistence/validation lives in `epiphany-core/src/heartbeat_state/heartbeat_store.rs`; heartbeat status/artifact JSON projection lives in `epiphany-core/src/heartbeat_state/heartbeat_projection.rs`; the root heartbeat module remains the scheduling/cognition orchestration surface until those responsibilities are split into their own tested seams. Heartbeat timing authority is now typed state: adaptive pacing, scene protocol, participant personality/mood timing, initiative heat projection, birth personality seed receipts, pending-turn freeze/multiplier facts, Void routine sleep-cycle physiology, Void routine memory-resonance pairs, incubation themes/source coverage, analytic/associative thought lanes, bridge syntheses/saturation/refractory cooling/decision, candidate interventions, role thought appraisals, and derived reactions are named fields rather than `extra` maps or generic JSON cargo. The only remaining heartbeat `extra` bag is the sealed legacy combined-state reader for old `voidRoutine` migration. - Heartbeat role/default and store seams are pinned by module-local unit tests for fixed lane catalog, Ghostlight scene role projection, and typed state/cognition CultCache round-trip. @@ -166,12 +167,12 @@ accepted_design: - Runtime-spine hello now advertises the interactive surface catalog as CultNet contracts, not just the deep runtime documents. Scene, pressure, reorient, CRRC, jobs, roles, role-result, reorient-result, planning, coordinator, Face, Void memory, and repo initialization/birth runner publish explicit read/write posture so Aquarium can discover affordances from the wire contract instead of carrying a private button-to-command gospel. Rider and Unity bridge contracts are quarantined optional environment surfaces until engine dogfood resumes. - Epiphany's public pitch is project-native agency, not just better prompting. Aquarium is the clearest client, but Discord roles, voice/WebRTC rooms, stream overlays, native CLIs, and other CultNet tools should all speak to the same typed project/Faces substrate. Faces advocate for repo needs, answer from jurisdiction, and can propose work; the scheduler and coordinator decide what thinks next, while review gates decide what may mutate canonical state. - Epiphany publishes its Aquarium-facing CultNet receipts locally under `schemas/cultnet/`, and `epiphany-runtime-spine schema-catalog --include-schema-json true` emits a merged builtin-plus-local schema catalog for consumers. The local receipts cover runtime-spine documents, durable agent/heartbeat/ledger state, `epiphany.surface.*` operator projections, control intents, and receipt/artifact payloads. Vendored `cultnet-rs` is aligned to the canonical C# CultNet raw record shapes: replication uses `schemaId` plus `recordKey`, snapshot filters use `schemaIds` / `recordKeys`, and hello advertises typed mutation contracts. - - Epiphany now owns the canonical schema paperwork in `schemas/`: a local mirror of `ghostlight.agent-state.schema.json`, plus human-facing receipts for canonical agent-state shape, standing role-trait glossary, heartbeat store shape, and repo-personality birth projection. Trait names like `routing_discipline` are now documented at the source instead of existing only in live dossiers, startup templates, or stale Ghostlight notes. - - The dossier doctrine now distinguishes `lane_core` from `embodied_actor`. Most Epiphany sub-agents want a lean role lattice plus memory/goals/values/private-note growth, because effectiveness matters more than theatrical density. Face and Ghostlight-style characters want dense Ghostlight-family personality, relationship pressure, perceived overlays, and appraisal-shaped fallibility. The classification is now queryable through native agent-memory status and character-loop packets instead of hiding only in docs. - - 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. + - Epiphany now owns the canonical schema paperwork in `schemas/`: a local mirror of `ghostlight.agent-state.schema.json`, plus human-facing receipts for canonical agent-state shape, standing role-trait glossary, heartbeat store shape, and repo-personality birth projection. Trait names like `routing_discipline` are now documented at the source instead of existing only in live organ-state records, startup templates, or stale Ghostlight notes. + - Organ-state doctrine now distinguishes `work_organ` from `persona`. Most Epiphany sub-agents want lean identity, memory, goals, values, private-note growth, and heartbeat activation because effectiveness matters more than theatrical density. Epiphany Face, VoidBot repo Faces, and Ghostlight characters want portable Persona state: denser personality, affect, relationship pressure, perceived overlays, and appraisal-shaped fallibility. The classification is now queryable through native agent-memory status, character-loop packets, and `epiphany.agent_utterance_state.v0` as `organStateProfile`. + - 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 organ-state record 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 mission-specific briefs for Self, Face, Imagination, Eyes, Proprioception, Hands, and Soul, plus Continuity protocol doctrine as typed state pressure rather than role memory. It petitions Self with role-specific Ghostlight-shaped memory candidates; it does not mutate memory, set objectives, copy raw dumps, or reset living memory after startup. + - Repo memory initialization is a separate birth-only organ from repo personality initialization. `epiphany-repo-personality memory-packet` uses the typed terrain/profile/projection store plus bounded source excerpts from doctrine, docs, state, research, contracts, verification, runtime, and code surfaces to render a Repo Memory Distiller packet with mission-specific briefs for Self, Face, Imagination, Eyes, Proprioception, Hands, and Soul, plus Continuity protocol doctrine as typed state pressure rather than role memory. It petitions Self with role-specific organ-state 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. @@ -197,11 +198,11 @@ accepted_design: - Major Epiphany prompt surfaces live in prompt files rather than Rust/Python string slabs: rendered state intro/doctrine under `epiphany-state-model/src/prompts/`, and modeling/Proprioception, research/Eyes, implementation/Hands, verification/Soul, reorientation/Continuity, coordinator/Self, Face/public-surface, and CRRC intervention templates in `epiphany-core/src/prompts/epiphany_specialists.toml`. - Specialist prompts are role-distilled instead of generic and their live text is config-backed in `epiphany-core`: modeling/checkpoint is Proprioception: code, dataflow, seams, and frontier; research/scout is the Eyes prompt surface for existing work, vendor guidance, libraries, papers, and anti-Greenspun source selection; implementation is the Hands, the main coding lane and actuator rather than a `roleLaunch` specialist; verification/review is the Soul of promise, invariants, evidence, and user truth; reorientation is a Continuity worker across compaction and source drift; coordinator is the read-only Self that routes attention without implementing, verifying, promoting, or accepting; Face is the public Discord #aquarium surface that translates agent thought-weather without moderating or leaking sealed thought. - Epiphany prompt surfaces now carry a shared Ghostlight-derived persistent memory projection before lane-specific text: prompt is not memory, durable typed state is the mind, personality and protected values are first-class salience handles, and every lane is explicitly responsible for making its own memory/model/prompt/evidence habit sharper or naming the needed repair. Each lane states self-improvement in its own rite-language: Imagination selects futures, Proprioception clarifies anatomy, Eyes sees earlier, Hands touches source more precisely, Soul becomes harder to fool, Continuity loses less context, Self routes repair, and Face becomes clearer at turning inner weather into useful social presence. - - Specialist self-memory now has a bounded Ghostlight-shaped CultCache persistence surface in `state/agents.msgpack`: Imagination, Proprioception, Eyes, Hands, Soul, Self, and Face each have an individual typed role dossier for identity, personality, semantic/episodic/relationship memory, goals, and values. Continuity has typed protocol receipts instead of a role dossier. These entries are lane memory only; project truth remains in authoritative `EpiphanyThreadState`. - - `state/agent-heartbeats.msgpack`, `epiphany-core::EpiphanyHeartbeatStateEntry`, and the native `epiphany-heartbeat-store` binary are the Ghostlight-derived heartbeat initiative seam. The harness sets a target heartbeat rate; participants carry arena, participant kind, initiative speed, next-ready time, reaction bias, interrupt threshold, current load, status, constraints, personality cooldown, mood cooldown, initiative heat, active-turn freeze state, and effective cooldown; pending coordinator work can pull its owning lane through a reaction window; otherwise the earliest ready active participant wins the slot. Role dossiers set the personality baseline, appraisals bend it with mood/anxiety signals such as urgency, arousal, thought pressure, guardedness, and reaction intensity, and lower effective cooldown means the lane recovers sooner and gets the floor more often. `HeartbeatMoodTiming` now also owns the 32-axis current affect vector used by utterance state: anger, despair, sadness, fear, contempt, annoyance, dismissal, flippancy, tenderness, warmth, shame, pride, fatigue, secrecy, hesitation, emotional containment, and related speech pressures are heartbeat physiology, not decorative prompt adjectives. Initiative heat is typed heartbeat policy, not a side flag: `epiphany-heartbeat-store heat` and the CultNet `epiphany.heartbeat_heat_intent.v0` contract can set or clear global, all, agent, role, arena, participant-kind, group, and constraint multipliers, with optional scene-clock expiry. Active thinking freezes initiative explicitly: running pending turns project `initiativeFrozen` / `initiative_frozen`, are ineligible for reaction, cannot be selected again, and start cooldown only after completion. The native `pump` command computes adaptive swarm pressure from external urgency, mood/anxiety, reaction intensity, thought pressure, and current pending load; relaxed pressure can launch nothing and run at crawl tempo, while alarm pressure can fill most or all active lanes up to a configured concurrency cap without waking any lane already running. If the winner has no routeable maintenance work, it ruminates on role quality and prepares bounded selfPatch pressure rather than pretending rumination has already consolidated doctrine. Sleep/dream cycle passes are the intended distillation window for reviewed self-memory and doctrine. Face can win `surfaceAgentThoughts` or `discordAquariumChat` work slots. Epiphany also owns native character-loop projection through `epiphany-character-loop`, so role dossiers can respond to visible stimuli without importing Ghostlight as runtime. The same heartbeat store now owns the Void-derived routine fields typed `sleep_cycle`, typed `memory_resonance`, `incubation`, `thought_lanes`, `bridge`, `candidate_interventions`, typed `appraisals`, and typed `reactions` through the native `epiphany-heartbeat-store routine` command. + - Specialist self-memory now has a bounded CultCache persistence surface in `state/agents.msgpack`: Imagination, Proprioception, Eyes, Hands, Soul, Self, and Face each have an individual typed organ-state record for identity, semantic/episodic/relationship memory, goals, values, and profile classification. Work organs stay light; Face may use portable Persona state. Continuity has typed protocol receipts instead of an organ-state record. 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. Organ-state records 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 organ-state records 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. - - VoidBot's current routine is reference lineage only. Epiphany's native routine pass lives in Rust as `epiphany-heartbeat-store routine`: it reads typed role dossiers, projects typed memory-resonance pair documents, maintains incubation themes, runs analytic and associative cognition lanes, writes bridge syntheses/saturation/tension, produces reviewed candidate interventions, advances typed sleep/dream-cycle state, and writes an auditable routine receipt while leaving project truth and role memory mutation on their dedicated reviewed surfaces. Qdrant-backed memory vectors remain a future enhancement; the current native pass uses bounded local resonance over typed memories. + - VoidBot's current routine is reference lineage only. Epiphany's native routine pass lives in Rust as `epiphany-heartbeat-store routine`: it reads typed organ-state records, projects typed memory-resonance pair documents, maintains incubation themes, runs analytic and associative cognition lanes, writes bridge syntheses/saturation/tension, produces reviewed candidate interventions, advances typed sleep/dream-cycle state, and writes an auditable routine receipt while leaving project truth and role memory mutation on their dedicated reviewed surfaces. Qdrant-backed memory vectors remain a future enhancement; the current native pass uses bounded local resonance over typed memories. - `epiphany-character-loop` now advertises `epiphany.cognition_lanes.v0` and `epiphany.cognition_bridge.v0` in every character-turn packet, and its projection/appraisal/reaction seeds reuse the typed heartbeat cognition documents before artifact serialization. Its utterance-state projection is the Weksa/AquaSynth speech seam: typed identity, trait vectors, values, current mood, activation, 32 named affect dimensions, and a 64-float character-state vector, with episodic/semantic/relationship memories deliberately excluded. Face and future role-local actors must run an analytic lane and an associative lane, then let the bridge choose bubble, draft, finding, silence, or bounded `selfPatch`; those lanes shape attention but do not mutate project truth. - The Rust CultCache-compatible contract now lives in dedicated upstream `https://github.com/GameCult/cultcache-rs` and is vendored as `vendor/cultcache-rs`. Epiphany should consume it as the canonical typed MessagePack persistence seam instead of growing an embedded local copy like an unsanctioned organ. - `state/face-discord.toml` and the native `epiphany-face-discord` binary are the Face Discord boundary. Face may interact only through #aquarium; missing or mismatched channel configuration produces candidate chat artifacts instead of posting elsewhere. When a Face has a configured persona name/avatar, posting uses the shared Discord webhook pipe so each Epiphany can speak with its own nickname and avatar without needing a separate bot identity. @@ -258,11 +259,11 @@ landed_baseline: - Phase 6 GUI planning operator slice: MVP status and Tauri/React GUI render planning state; old Python GUI action shims have been cut from EpiphanyAgent. - Phase 6 Imagination role lane: the `roles` view lens exposes Imagination/planning, `roleLaunch` can launch the fixed `planning-synthesis-worker`, `roleResult` projects its finding, `roleAccept` applies planning-only patches with review-gated Objective Drafts, and the GUI/status tools can launch, read, and accept that lane. - Phase 6 Aquarium graph and Rider bridge slice: the Tauri/React/WebGL Aquarium embeds the adjacent EpiphanyGraph viewer over typed graph state, native `epiphany-rider-bridge` writes Rider/source-context artifacts, Aquarium Inspect Rider surfaces those artifacts, and `integrations/rider` scaffolds the first frontend-only Rider tool-window/context-action plugin. - - 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 role self-memory slice: local organ-state records 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 organ-state record, 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 typed organ-state record from `state/agents.msgpack`, combines it with a visible stimulus, builds typed projection/appraisal/reaction seeds from the shared heartbeat cognition structs, and emits an auditable `epiphany.character_turn_packet.v0` local projection for response, bubble, finding, silence, or bounded `selfPatch`. Face is the first intended public-surface consumer; Ghostlight is reference material, not a runtime dependency. - Phase 6 heartbeat initiative slice: `state/agent-heartbeats.msgpack`, `epiphany-core::EpiphanyHeartbeatStateEntry`, the native `epiphany-heartbeat-store` binary, and heartbeat smoke coverage borrow Ghostlight initiative scheduling so Self, Face, Imagination, Eyes, Proprioception, Hands, and Soul compete for heartbeat slots; idle slots become bounded rumination instead of fake project work, and sleep/dream cycle passes emit Continuity protocol receipts rather than waking a Continuity persona. The live state surface now ticks/completes/pumps/applies heartbeat physiology through typed CultCache MessagePack instead of JSON or Python wrapper state. Role personality and current mood/anxiety both shape initiative recovery through personality, mood, and effective cooldown multipliers, so Hands-like work pressure and anxious high-need lanes can recover sooner without waking lanes whose previous turn is still running. Adaptive pump pressure controls tempo and concurrency: calm can launch zero and sleep slow; alarm can fill most active lanes. The same store can now initialize a `ghostlight-scene` profile for character scene turns. - - Phase 6 cognition-lanes/Void routine slice: native `epiphany-heartbeat-store routine` rebuilds VoidBot-style sleep, resonance, incubation, parallel analytic/associative thought lanes, bridge judgment, candidate interventions, Ghostlight-style participant-local thought appraisal, derived reactions, dream maintenance, and mood/anxiety timing inside Epiphany's heartbeat store. It now also carries Void's anti-loop organs: split `noveltyToSelf`/`noveltyToRoom`, source coverage, saturation pressure, refractory cooling, and explicit permission to let a live unsaturated thought deepen without forced novelty theater. It reads typed role dossiers from `state/agents.msgpack`, projects clustered thought state through each role's personality vectors, updates `state/agent-heartbeats.msgpack`, and emits an auditable `epiphany.void_routine.v0` receipt without importing VoidBot or granting speech/project authority. `epiphany-character-loop` also carries the same cognition lane/bridge/appraisal contract for role-local actor turns; reactions may pace, color, draft, or display behavior, but state mutation remains on reviewed `selfPatch` or project-state surfaces. + - 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 organ-state records 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 role personality projections for the embodied sub-agent lanes from deterministic repo inventory and git-history scoring, then renders a birth-only Repo Personality Distiller specialist packet and prompt for review-gated initial personality quirk petitions; `epiphany-repo-personality-smoke` proves scout/project/agent-packet/status over tiny local repos. - Native repo trajectory scout/birth-distiller packet slice: `epiphany-repo-personality` now also emits typed `repo_trajectory_report` documents from early-history, recent-history, doctrine/content excerpts, and deterministic theme scoring, then renders a birth-only Repo Trajectory Distiller packet so newborn swarms can inherit historical direction, self-image, implicit goals, and anti-goals without confusing those with active objectives. @@ -286,7 +287,7 @@ landed_baseline: - Use `cargo run --manifest-path .\epiphany-core\Cargo.toml --bin epiphany-mvp-coordinator-smoke` before modifying the fixed-lane MVP coordinator endpoint or runner. - Use `cargo test --manifest-path .\epiphany-core\Cargo.toml --lib runtime_spine -- --nocapture` and `cargo build --manifest-path .\epiphany-core\Cargo.toml --bin epiphany-runtime-spine` before modifying native runtime-spine state or CultNet hello emission. - Use focused app-server/core Rust checks before modifying explicit role launch/read-back/acceptance behavior. - - Use `cargo run --manifest-path .\epiphany-core\Cargo.toml --bin epiphany-agent-memory-store -- smoke --store .\state\agents.msgpack` before modifying role self-memory dossiers or `selfPatch` persistence policy. + - Use `cargo run --manifest-path .\epiphany-core\Cargo.toml --bin epiphany-agent-memory-store -- smoke --store .\state\agents.msgpack` before modifying organ self-memory records or `selfPatch` persistence policy. - Use `cargo run --manifest-path .\epiphany-core\Cargo.toml --bin epiphany-heartbeat-store -- smoke --agent-store .\state\agents.msgpack` before modifying heartbeat initiative timing, idle rumination, or role slot selection. - Use `cargo run --manifest-path .\epiphany-core\Cargo.toml --bin epiphany-repo-personality-smoke` before modifying repo trajectory/personality terrain scoring, birth packet shape, startup-init routing, source excerpt selection, or role-specific initialization memory contracts. - Use `cargo run --manifest-path .\epiphany-core\Cargo.toml --bin epiphany-face-discord -- smoke` before modifying Face's #aquarium posting/draft guardrails.