diff --git a/epiphany-core/src/bin/epiphany-character-loop.rs b/epiphany-core/src/bin/epiphany-character-loop.rs index 972bd324..5084d7f8 100644 --- a/epiphany-core/src/bin/epiphany-character-loop.rs +++ b/epiphany-core/src/bin/epiphany-character-loop.rs @@ -1,12 +1,15 @@ -use anyhow::anyhow; use anyhow::Context; use anyhow::Result; +use anyhow::anyhow; use chrono::SecondsFormat; -use epiphany_core::dossier_profile_for_role; -use epiphany_core::load_agent_memory_entry_for_role; use epiphany_core::EpiphanyAgentMemoryEntry; use epiphany_core::GhostlightMemory; +use epiphany_core::GhostlightTraitVector; +use epiphany_core::dossier_profile_for_role; +use epiphany_core::load_agent_memory_entry_for_role; use serde_json::Value; +use std::collections::BTreeMap; +use std::collections::BTreeSet; use std::env; use std::fs; use std::io::Read; @@ -117,6 +120,10 @@ fn character_turn_packet( mood: &str, ) -> Value { let dossier_profile = dossier_profile_for_role(&entry.role_id); + let projection_seed = + deterministic_projection_seed(entry, stimulus, source, mode, status, mood); + let appraisal_seed = deterministic_appraisal_seed(entry, &projection_seed, stimulus, source); + let reaction_seed = deterministic_reaction_seed(&entry.role_id, &appraisal_seed); serde_json::json!({ "schema_version": CHARACTER_TURN_SCHEMA_VERSION, "protocol": { @@ -168,8 +175,12 @@ fn character_turn_packet( "semanticMemories": entry.agent.memories.semantic.iter().map(memory_projection).collect::>(), "episodicMemories": entry.agent.memories.episodic.iter().map(memory_projection).collect::>(), "relationshipMemories": entry.agent.memories.relationship_summaries.iter().map(memory_projection).collect::>(), + "perceivedStateOverlays": entry.agent.perceived_state_overlays.iter().take(6).cloned().collect::>(), "privateNoteCount": entry.agent.identity.private_notes.len(), }, + "projectionSeed": projection_seed, + "appraisalSeed": appraisal_seed, + "reactionSeed": reaction_seed, "allowedOutputs": [ "bubble", "discordAquariumDraft", @@ -241,6 +252,456 @@ fn memory_projection(memory: &GhostlightMemory) -> Value { }) } +#[derive(Clone, Debug)] +struct TraitSignal { + group: &'static str, + name: String, + activation: f64, + plasticity: f64, + weight: f64, +} + +fn deterministic_projection_seed( + entry: &EpiphanyAgentMemoryEntry, + stimulus: &str, + source: &str, + mode: &str, + status: &str, + mood: &str, +) -> Value { + let thought_tokens = stimulus_token_set(stimulus, source, mode, status, mood); + let traits = collect_trait_signals(entry); + let mut scored = traits + .iter() + .map(|item| { + let trait_tokens = summary_tokens(&format!("{} {}", item.group, item.name)); + let overlap = token_overlap(&trait_tokens, &thought_tokens); + let projection = round3((item.weight * (0.55 + overlap * 1.8)).clamp(0.0, 1.0)); + serde_json::json!({ + "group": item.group, + "name": item.name, + "activation": round3(item.activation), + "plasticity": round3(item.plasticity), + "tokenOverlap": round3(overlap), + "projection": projection, + }) + }) + .collect::>(); + scored.sort_by(|left, right| { + right["projection"] + .as_f64() + .unwrap_or_default() + .total_cmp(&left["projection"].as_f64().unwrap_or_default()) + }); + scored.truncate(6); + + let (relationship_pressure, relationship_summary) = + strongest_relationship_pressure(entry, &thought_tokens); + let (overlay_pressure, overlay_summary) = strongest_overlay_pressure(entry, &thought_tokens); + + serde_json::json!({ + "schema_version": "epiphany.personality_projection.v0", + "participantAgentId": entry.agent.agent_id, + "roleId": entry.role_id, + "thoughtClusterRef": format!("{}#stimulus", source), + "thoughtTokens": thought_tokens.into_iter().collect::>(), + "dominantTraitMatches": scored, + "relationshipPressure": { + "strength": round3(relationship_pressure), + "summary": relationship_summary, + }, + "perceivedOverlayPressure": { + "strength": round3(overlay_pressure), + "summary": overlay_summary, + }, + "contract": "Projection is participant-local and fallible. It is a seed for embodied response, not reviewed project truth.", + }) +} + +fn deterministic_appraisal_seed( + entry: &EpiphanyAgentMemoryEntry, + projection_seed: &Value, + stimulus: &str, + source: &str, +) -> Value { + let traits = collect_trait_signals(entry); + let reactivity = average(traits.iter().take(8).map(|item| item.activation)).unwrap_or(0.5); + let plasticity = average(traits.iter().take(8).map(|item| item.plasticity)).unwrap_or(0.5); + let expressiveness = average( + traits + .iter() + .filter(|item| item.group == "voice_style" || item.group == "presentation_strategy") + .map(|item| item.activation), + ) + .unwrap_or(reactivity); + let guarded_baseline = average( + traits + .iter() + .filter(|item| { + let name = item.name.as_str(); + name.contains("guard") + || name.contains("shame") + || name.contains("risk") + || name.contains("caution") + || name.contains("contingent") + || name.contains("defens") + || name.contains("susp") + }) + .map(|item| item.activation), + ) + .unwrap_or((1.0 - expressiveness * 0.45).clamp(0.0, 1.0)); + let alignment = projection_seed + .pointer("/dominantTraitMatches/0/projection") + .and_then(Value::as_f64) + .unwrap_or(reactivity); + let relationship_pressure = projection_seed + .pointer("/relationshipPressure/strength") + .and_then(Value::as_f64) + .unwrap_or(0.0); + let overlay_pressure = projection_seed + .pointer("/perceivedOverlayPressure/strength") + .and_then(Value::as_f64) + .unwrap_or(0.0); + let thought_pressure = (0.18 + + (summary_tokens(stimulus).len() as f64 / 18.0).min(0.42) + + relationship_pressure * 0.22 + + overlay_pressure * 0.18) + .clamp(0.0, 1.0); + let arousal = + round3((thought_pressure * (0.35 + reactivity * 0.45 + plasticity * 0.2)).clamp(0.0, 1.0)); + let guardedness = round3( + (guarded_baseline * 0.58 + + relationship_pressure * 0.18 + + overlay_pressure * 0.14 + + (1.0 - alignment) * 0.10) + .clamp(0.0, 1.0), + ); + let curiosity = + round3(((1.0 - guardedness) * 0.22 + alignment * 0.46 + plasticity * 0.32).clamp(0.0, 1.0)); + let urgency = + round3((arousal * 0.58 + guardedness * 0.22 + thought_pressure * 0.20).clamp(0.0, 1.0)); + let valence = round3((0.52 + curiosity * 0.22 - guardedness * 0.20).clamp(0.0, 1.0)); + let label = interpretation_label("draft", arousal, guardedness, curiosity); + serde_json::json!({ + "schema_version": "epiphany.agent_thought_appraisal.v0", + "appraisalId": format!("face-appraisal-{}", short_id()), + "reviewStatus": "generated_unreviewed", + "participantAgentId": entry.agent.agent_id, + "roleId": entry.role_id, + "currentCharacterStateRef": format!("state/agents.msgpack#{}", entry.role_id), + "thoughtClusterRef": format!("{}#stimulus", source), + "observableThoughtSummary": stimulus, + "participantLocalContext": { + "displayName": entry.agent.identity.name, + "valueLabels": entry + .agent + .canonical_state + .values + .iter() + .take(5) + .map(|value| value.label.clone()) + .collect::>(), + "reactivity": round3(reactivity), + "plasticity": round3(plasticity), + "expressiveness": round3(expressiveness), + "guardedness": round3(guarded_baseline), + "relationshipMemoryCount": entry.agent.memories.relationship_summaries.len(), + "perceivedOverlayCount": entry.agent.perceived_state_overlays.len(), + }, + "personalityProjection": projection_seed, + "interpretation": format!( + "{} appraises the visible stimulus through its local personality, relationship memory, and perceived overlays; this is embodied response guidance, not omniscient truth.", + entry.agent.identity.name + ), + "emotionalAppraisal": { + "valence": valence, + "arousal": arousal, + "urgency": urgency, + "curiosity": curiosity, + "guardedness": guardedness, + "thoughtPressure": round3(thought_pressure), + }, + "interpretationLabel": label, + "candidateImplications": { + "reactionMode": reaction_mode(&label, "draft"), + "reactionIntensity": round3((urgency * 0.55 + arousal * 0.3 + curiosity * 0.15).clamp(0.0, 1.0)), + "shouldSpeak": entry.role_id == "face" && guardedness < 0.78, + "shouldIncubate": guardedness >= 0.55, + }, + "confidenceNotes": "Deterministic Face-local appraisal rebuilt from the same Ghostlight-style personality projection logic used by heartbeat. Useful for reaction shape, still reviewable and fallible.", + "review": { + "acceptedForMutation": false, + "rationale": "Appraisal may steer expression and reaction; state mutation still requires explicit review.", + } + }) +} + +fn deterministic_reaction_seed(role_id: &str, appraisal_seed: &Value) -> Value { + let arousal = appraisal_seed + .pointer("/emotionalAppraisal/arousal") + .and_then(Value::as_f64) + .unwrap_or(0.0); + let guardedness = appraisal_seed + .pointer("/emotionalAppraisal/guardedness") + .and_then(Value::as_f64) + .unwrap_or(0.0); + let curiosity = appraisal_seed + .pointer("/emotionalAppraisal/curiosity") + .and_then(Value::as_f64) + .unwrap_or(0.0); + let mode = appraisal_seed + .pointer("/candidateImplications/reactionMode") + .and_then(Value::as_str) + .unwrap_or("incubate"); + let intensity = appraisal_seed + .pointer("/candidateImplications/reactionIntensity") + .and_then(Value::as_f64) + .unwrap_or(0.0); + serde_json::json!({ + "schema_version": "epiphany.agent_reaction.v0", + "reactionId": format!("reaction-{}-{}", role_id, short_id()), + "roleId": role_id, + "appraisalId": appraisal_seed.get("appraisalId"), + "mode": mode, + "moodLabel": mood_label(arousal, guardedness, curiosity), + "intensity": round3(intensity), + "surface": if role_id == "face" { "aquarium" } else { "internal" }, + "recommendedUse": reaction_recommended_use(role_id, mode), + "contract": "Reaction is derived from local appraisal and may color speech or silence; it still does not mutate durable state by itself.", + }) +} + +fn collect_trait_signals(entry: &EpiphanyAgentMemoryEntry) -> Vec { + let mut traits = Vec::new(); + collect_trait_group( + &mut traits, + "underlying_organization", + &entry.agent.canonical_state.underlying_organization, + ); + collect_trait_group( + &mut traits, + "stable_dispositions", + &entry.agent.canonical_state.stable_dispositions, + ); + collect_trait_group( + &mut traits, + "behavioral_dimensions", + &entry.agent.canonical_state.behavioral_dimensions, + ); + collect_trait_group( + &mut traits, + "presentation_strategy", + &entry.agent.canonical_state.presentation_strategy, + ); + collect_trait_group( + &mut traits, + "voice_style", + &entry.agent.canonical_state.voice_style, + ); + collect_trait_group( + &mut traits, + "situational_state", + &entry.agent.canonical_state.situational_state, + ); + traits.sort_by(|left, right| right.weight.total_cmp(&left.weight)); + traits +} + +fn collect_trait_group( + traits: &mut Vec, + group: &'static str, + source: &BTreeMap, +) { + for (name, vector) in source { + let activation = vector.current_activation.clamp(0.0, 1.0); + let plasticity = vector.plasticity.clamp(0.0, 1.0); + traits.push(TraitSignal { + group, + name: name.clone(), + activation, + plasticity, + weight: round3(activation * (0.65 + plasticity * 0.35)), + }); + } +} + +fn strongest_relationship_pressure( + entry: &EpiphanyAgentMemoryEntry, + thought_tokens: &BTreeSet, +) -> (f64, String) { + entry + .agent + .memories + .relationship_summaries + .iter() + .map(|memory| { + let overlap = token_overlap(&summary_tokens(&memory.summary), thought_tokens); + let strength = overlap * (memory.salience * memory.confidence); + (strength, memory.summary.clone()) + }) + .max_by(|left, right| left.0.total_cmp(&right.0)) + .map(|(strength, summary)| (round3(strength.clamp(0.0, 1.0)), summary)) + .unwrap_or(( + 0.0, + "No strong relationship pressure is active.".to_string(), + )) +} + +fn strongest_overlay_pressure( + entry: &EpiphanyAgentMemoryEntry, + thought_tokens: &BTreeSet, +) -> (f64, String) { + entry + .agent + .perceived_state_overlays + .iter() + .map(|overlay| { + let mut tokens = BTreeSet::new(); + collect_json_tokens(overlay, &mut tokens); + let overlap = token_overlap(&tokens, thought_tokens); + let summary = overlay + .get("summary") + .and_then(Value::as_str) + .or_else(|| overlay.get("label").and_then(Value::as_str)) + .unwrap_or("Perceived overlay relevance"); + (overlap, summary.to_string()) + }) + .max_by(|left, right| left.0.total_cmp(&right.0)) + .map(|(strength, summary)| (round3(strength.clamp(0.0, 1.0)), summary)) + .unwrap_or(( + 0.0, + "No perceived overlay is tugging on this stimulus.".to_string(), + )) +} + +fn stimulus_token_set( + stimulus: &str, + source: &str, + mode: &str, + status: &str, + mood: &str, +) -> BTreeSet { + let mut tokens = BTreeSet::new(); + tokens.extend(summary_tokens(stimulus)); + tokens.extend(summary_tokens(source)); + tokens.extend(summary_tokens(mode)); + tokens.extend(summary_tokens(status)); + tokens.extend(summary_tokens(mood)); + tokens +} + +fn collect_json_tokens(value: &Value, tokens: &mut BTreeSet) { + match value { + Value::String(text) => tokens.extend(summary_tokens(text)), + Value::Array(items) => { + for item in items { + collect_json_tokens(item, tokens); + } + } + Value::Object(object) => { + for (key, value) in object { + tokens.extend(summary_tokens(key)); + collect_json_tokens(value, tokens); + } + } + _ => {} + } +} + +fn summary_tokens(text: &str) -> BTreeSet { + text.split(|ch: char| !ch.is_ascii_alphanumeric() && ch != '_' && ch != '-') + .filter_map(|item| { + let token = item.trim().to_ascii_lowercase().replace('_', "-"); + (token.len() >= 3).then_some(token) + }) + .collect() +} + +fn token_overlap(left: &BTreeSet, right: &BTreeSet) -> f64 { + if left.is_empty() || right.is_empty() { + return 0.0; + } + let shared = left.intersection(right).count() as f64; + let denom = left.len().min(right.len()) as f64; + if denom <= f64::EPSILON { + 0.0 + } else { + (shared / denom).clamp(0.0, 1.0) + } +} + +fn average(values: I) -> Option +where + I: Iterator, +{ + let mut total = 0.0_f64; + let mut count = 0_usize; + for value in values { + total += value; + count += 1; + } + (count > 0).then_some(total / count as f64) +} + +fn interpretation_label( + bridge_decision: &str, + arousal: f64, + guardedness: f64, + curiosity: f64, +) -> String { + if guardedness > 0.72 && arousal > 0.35 { + "protective_appraisal".to_string() + } else if curiosity > 0.68 { + "investigative_appraisal".to_string() + } else if bridge_decision == "draft" { + "expressive_appraisal".to_string() + } else if arousal < 0.12 { + "low_pressure_appraisal".to_string() + } else { + "incubating_appraisal".to_string() + } +} + +fn reaction_mode(label: &str, bridge_decision: &str) -> &'static str { + match (label, bridge_decision) { + ("protective_appraisal", _) => "hold_and_verify", + ("investigative_appraisal", _) => "inspect", + ("expressive_appraisal", "draft") => "draft", + ("low_pressure_appraisal", _) => "sleep_ruminate", + _ => "incubate", + } +} + +fn mood_label(arousal: f64, guardedness: f64, curiosity: f64) -> &'static str { + if guardedness > 0.72 && arousal > 0.35 { + "wary" + } else if curiosity > 0.68 && arousal > 0.25 { + "keen" + } else if arousal < 0.12 { + "drowsy" + } else if guardedness > curiosity { + "watchful" + } else { + "interested" + } +} + +fn reaction_recommended_use(role_id: &str, mode: &str) -> &'static str { + match (role_id, mode) { + ("face", "draft") => "Prepare a reviewed Aquarium-facing draft; do not post automatically.", + (_, "hold_and_verify") => "Bias toward verifier/modeler review before expression.", + (_, "inspect") => { + "Bias the next heartbeat toward a bounded retrieval or modeling inspection." + } + (_, "sleep_ruminate") => "Let this organ sleep-ruminate unless real work arrives.", + _ => "Keep the thought incubating and visible in Aquarium.", + } +} + +fn round3(value: f64) -> f64 { + (value.clamp(0.0, 1.0) * 1000.0).round() / 1000.0 +} + fn run_smoke() -> Result { let temp_dir = scoped_temp_dir("epiphany-character-loop-smoke")?; let artifact_dir = temp_dir.join("artifacts"); @@ -268,6 +729,9 @@ fn run_smoke() -> Result { && packet["protocol"]["roleId"] == "face" && packet["protocol"]["dossierProfile"]["profileKind"] == "embodied_actor" && packet["projectedLocalContext"]["dossierProfile"]["profileKind"] == "embodied_actor" + && packet["projectionSeed"]["schema_version"] == "epiphany.personality_projection.v0" + && packet["appraisalSeed"]["schema_version"] == "epiphany.agent_thought_appraisal.v0" + && packet["reactionSeed"]["schema_version"] == "epiphany.agent_reaction.v0" && packet["projectedLocalContext"]["identity"]["name"] .as_str() .is_some_and(|name| !name.trim().is_empty()) @@ -287,6 +751,9 @@ fn run_smoke() -> Result { "roleId": packet["protocol"]["roleId"], "agentId": packet["protocol"]["agentId"], "dossierProfile": packet["protocol"]["dossierProfile"]["profileKind"], + "projectionSchema": packet["projectionSeed"]["schema_version"], + "appraisalSchema": packet["appraisalSeed"]["schema_version"], + "reactionSchema": packet["reactionSeed"]["schema_version"], "identityName": packet["projectedLocalContext"]["identity"]["name"], "allowedOutputs": packet["allowedOutputs"], "cognitionLanes": packet["cognitionLanes"]["schema_version"], diff --git a/epiphany-core/src/lib.rs b/epiphany-core/src/lib.rs index 6a97c51e..0eb749ce 100644 --- a/epiphany-core/src/lib.rs +++ b/epiphany-core/src/lib.rs @@ -16,6 +16,7 @@ pub use agent_memory::EpiphanyAgentMemoryEntry; pub use agent_memory::EpiphanyDossierProfile; pub use agent_memory::EpiphanyDossierProfileKind; pub use agent_memory::GhostlightMemory; +pub use agent_memory::GhostlightTraitVector; pub use agent_memory::agent_memory_status; pub use agent_memory::apply_agent_canonical_trait_seeds; pub use agent_memory::apply_agent_self_patch; diff --git a/notes/fresh-workspace-handoff.md b/notes/fresh-workspace-handoff.md index c0adfdd0..98d06795 100644 --- a/notes/fresh-workspace-handoff.md +++ b/notes/fresh-workspace-handoff.md @@ -39,6 +39,7 @@ remembers doctrine; the branch remembers the blade. - 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 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. - 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` now owns the startup-only execution path: plan mode writes Codex execution prompts/schemas/accept commands, and run mode invokes `codex exec` with the packet schema and captures reviewable `result.json`. The remaining seam is Aquarium review/action surfacing. After accepted birth, personality drift belongs to heartbeat, mood, rumination, sleep consolidation, lived evidence, and reviewed `selfPatch`, not repeated startup distillation. - Repo trajectory initialization is now a separate birth-only organ. `epiphany-repo-personality` derives a typed `repo_trajectory_report` from early-history, recent-history, doctrine/content excerpts, and deterministic theme scoring, and `trajectory-packet` renders a startup-only Repo Trajectory Distiller prompt/packet so Self can review historical direction, self-image, implicit goals, and anti-goals before the newborn wakes. - Repo memory initialization is now split from personality initialization. `epiphany-repo-personality memory-packet` renders a birth-only Repo Memory Distiller packet from the same typed terrain/profile/projection store plus bounded source excerpts. It gives each organ its own mission filter: Self for routing/authority, Face for public surface, Imagination for plans/backlog, Eyes for prior art, Body for architecture, Hands for implementation habits, Soul for evidence, and Life for continuity. The output is still a Self-reviewed petition, not direct memory mutation. diff --git a/schemas/dossier-profiles.md b/schemas/dossier-profiles.md index cc79d568..2c89b18b 100644 --- a/schemas/dossier-profiles.md +++ b/schemas/dossier-profiles.md @@ -54,6 +54,8 @@ Failure mode if overbuilt: 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 @@ -95,6 +97,7 @@ 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 diff --git a/state/ledgers.msgpack b/state/ledgers.msgpack index 481baeb5..d4c75121 100644 Binary files a/state/ledgers.msgpack and b/state/ledgers.msgpack differ diff --git a/state/map.yaml b/state/map.yaml index a1b1e857..1dd14004 100644 --- a/state/map.yaml +++ b/state/map.yaml @@ -120,6 +120,7 @@ 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, repo initialization/birth runner, Rider bridge, and Unity bridge all publish explicit read/write posture so Aquarium can discover affordances from the wire contract instead of carrying a private button-to-command gospel. - 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 memories, perceived overlays, and visible stimulus. This makes embodied response machinery available to the public mouth without granting omniscience or silent state mutation. Multiple Face actors remain part of the long-plan; the current singular `face` role is an MVP simplification, not the intended endpoint. - Repo personality initialization is now specified as a map-reduce projection, not a hand-written vibe pass: read-only scouts score body taxonomy, history temperament, and memory doctrine across nearby repos, reduce them into normalized variance criteria, and emit reviewable `repoTerrainReport`, `repoPersonalityProfile`, and `rolePersonalityProjection` candidates before touching agent memory. - Native `epiphany-repo-personality` is the first startup-personality scout and birth-only distiller packet renderer: it deterministically inventories local git repos, scores repo terrain/history/state surfaces, writes typed CultCache terrain/profile/role-projection MessagePack stores, emits JSON/Markdown inspection glass, and renders a Repo Personality Distiller specialist prompt packet for Self-reviewed first role-memory petitions. The distiller must run only when a repo/swarm has no accepted personality initialization; after that, personality drift belongs to heartbeat, mood, rumination, sleep consolidation, lived evidence, and reviewed `selfPatch`. Startup routing now checks accepted initialization records, generates missing startup-only packets only once, applies reviewed birth memory and heartbeat physiology seeds, and leaves later drift alone. Birth specialists are not heartbeat lanes; heartbeat receives only accepted seed pressure. - Repo memory initialization is a separate birth-only organ from repo personality initialization. `epiphany-repo-personality memory-packet` uses the typed terrain/profile/projection store plus bounded source excerpts from doctrine, docs, state, research, contracts, verification, runtime, and code surfaces to render a Repo Memory Distiller packet with one mission-specific brief for Self, Face, Imagination, Eyes, Body, Hands, Soul, and Life. It petitions Self with role-specific Ghostlight-shaped memory candidates; it does not mutate memory, set objectives, copy raw dumps, or reset living memory after startup.