diff --git a/crates/ghostlight-dungeon/src/assessor.rs b/crates/ghostlight-dungeon/src/assessor.rs index 6cdeefc..f1be0da 100644 --- a/crates/ghostlight-dungeon/src/assessor.rs +++ b/crates/ghostlight-dungeon/src/assessor.rs @@ -1,6 +1,10 @@ use crate::{ domain::{ActionAssessment, ActionIntent, Campaign, ContextModifier, WorldEffectDelta}, - model::{ModelPort, ModelStageReceipt, ModelStageRequest, run_validated_stage}, + model::{ + ModelPort, ModelProviderAttemptReceipt, ModelStageReceipt, ModelStageRequest, + ModelTokenUsage, run_validated_stage, + }, + persistence::CampaignStore, session_zero::{AggregatedBoundary, CampaignContract, ExtraordinaryPermission}, }; use anyhow::{Result, anyhow}; @@ -10,7 +14,11 @@ use serde::{Deserialize, Serialize}; use sha2::{Digest, Sha256}; use std::{collections::BTreeSet, sync::Arc}; -#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)] +const ASSESSMENT_PROPOSAL_CACHE_KIND: &str = "assessment_proposal_cache.v1"; +const ASSESSMENT_PROPOSAL_CACHE_SCHEMA: &str = "ghostlight.private.assessment_proposal_cache.v1"; +const ASSESSMENT_SEMANTICS_VERSION: &str = "ghostlight.action_assessment.v2"; + +#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)] struct AssessmentProposal { normalized_intent: String, admissible: bool, @@ -28,6 +36,17 @@ struct AssessmentProposal { bargains: Vec, } +#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] +struct AssessmentProposalCacheEntry { + schema: String, + basis_digest: String, + proposal: AssessmentProposal, + source_provider: String, + source_model: String, + source_receipt_hash: String, + created_at: chrono::DateTime, +} + pub struct ActionAssessor { model: Arc, model_id: String, @@ -64,6 +83,46 @@ impl ActionAssessor { extraordinary_permissions: &[ExtraordinaryPermission], campaign_contract: Option<&CampaignContract>, aggregate_boundaries: &[AggregatedBoundary], + ) -> Result<(ActionAssessment, ModelStageReceipt)> { + self.assess_with_context_inner( + None, + campaign, + intent, + extraordinary_permissions, + campaign_contract, + aggregate_boundaries, + ) + .await + } + + pub async fn assess_with_context_cached( + &self, + store: &CampaignStore, + campaign: &Campaign, + intent: ActionIntent, + extraordinary_permissions: &[ExtraordinaryPermission], + campaign_contract: Option<&CampaignContract>, + aggregate_boundaries: &[AggregatedBoundary], + ) -> Result<(ActionAssessment, ModelStageReceipt)> { + self.assess_with_context_inner( + Some(store), + campaign, + intent, + extraordinary_permissions, + campaign_contract, + aggregate_boundaries, + ) + .await + } + + async fn assess_with_context_inner( + &self, + store: Option<&CampaignStore>, + campaign: &Campaign, + intent: ActionIntent, + extraordinary_permissions: &[ExtraordinaryPermission], + campaign_contract: Option<&CampaignContract>, + aggregate_boundaries: &[AggregatedBoundary], ) -> Result<(ActionAssessment, ModelStageReceipt)> { let actor = campaign .actors @@ -125,6 +184,34 @@ impl ActionAssessor { serde_json::to_string(&allowed_references)? ); let snapshot_binding = format!("campaign:{}:revision:{}", campaign.id, campaign.revision); + let basis_digest = assessment_basis_digest(&self.model_id, &base_prompt); + if let Some(store) = store + && let Some((_, cached)) = store.load::( + ASSESSMENT_PROPOSAL_CACHE_KIND, + &basis_digest, + )? + { + if cached.schema != ASSESSMENT_PROPOSAL_CACHE_SCHEMA + || cached.basis_digest != basis_digest + { + return Err(anyhow!("assessment proposal cache identity mismatch")); + } + let proposal = validate_and_bind_proposal( + cached.proposal.clone(), + campaign, + actor, + &allowed_references, + )?; + let assessment = build_assessment(campaign, intent, proposal.clone())?; + let receipt = cache_hit_receipt( + &cached, + &proposal, + &snapshot_binding, + &base_prompt, + &campaign.branch_origin.evidence_receipt_ids, + )?; + return Ok((assessment, receipt)); + } let mut correction = String::new(); let mut attempts = 0; let (proposal, out) = loop { @@ -144,22 +231,12 @@ impl ActionAssessor { ) .await?; let candidate = (|| -> Result { - let mut proposal: AssessmentProposal = serde_json::from_value( + let proposal: AssessmentProposal = serde_json::from_value( out.structured .clone() .ok_or_else(|| anyhow!("assessor returned no typed proposal"))?, )?; - bind_visible_knowledge(&mut proposal)?; - validate_proposal(&proposal, &allowed_references)?; - for (effect, stake) in [ - (&proposal.strong_effect, &proposal.success_stake), - (&proposal.success_effect, &proposal.success_stake), - (&proposal.mixed_effect, &proposal.mixed_stake), - (&proposal.failure_effect, &proposal.failure_stake), - ] { - validate_effect(campaign, actor, effect, stake)?; - } - Ok(proposal) + validate_and_bind_proposal(proposal, campaign, actor, &allowed_references) })(); match candidate { Ok(proposal) => break (proposal, out), @@ -180,35 +257,190 @@ impl ActionAssessor { } } }; - let modifier_total = - crate::d20::capped_modifier(proposal.modifiers.iter().map(|m| m.value)); - let mut assessment = ActionAssessment { - schema: "ghostlight.player_action_assessment.v1".into(), - campaign_id: campaign.id, - revision: campaign.revision, - intent, - admissible: proposal.admissible, - missing_permission: proposal.missing_permission, - dc: proposal.dc, - modifiers: proposal.modifiers, - modifier_total, - effect_ceiling: proposal.effect_ceiling, - success_stake: proposal.success_stake, - mixed_stake: proposal.mixed_stake, - failure_stake: proposal.failure_stake, - strong_effect: proposal.strong_effect, - success_effect: proposal.success_effect, - mixed_effect: proposal.mixed_effect, - failure_effect: proposal.failure_effect, - bargains: proposal.bargains, - expires_at: Utc::now() + Duration::minutes(10), - digest: String::new(), - }; - assessment.digest = assessment_digest(&assessment)?; - Ok((assessment, out.receipt)) + let mut selected_proposal = proposal; + let mut selected_receipt = out.receipt; + if let Some(store) = store { + let entry = AssessmentProposalCacheEntry { + schema: ASSESSMENT_PROPOSAL_CACHE_SCHEMA.into(), + basis_digest: basis_digest.clone(), + proposal: selected_proposal.clone(), + source_provider: selected_receipt.provider.clone(), + source_model: selected_receipt.model.clone(), + source_receipt_hash: selected_receipt.receipt_hash.clone(), + created_at: Utc::now(), + }; + if let Err(insert_error) = store.insert( + ASSESSMENT_PROPOSAL_CACHE_KIND, + ASSESSMENT_PROPOSAL_CACHE_SCHEMA, + &basis_digest, + &entry, + ) { + let (_, winner) = store + .load::( + ASSESSMENT_PROPOSAL_CACHE_KIND, + &basis_digest, + )? + .ok_or_else(|| { + anyhow!( + "assessment proposal cache insert failed without an existing winner: {insert_error}" + ) + })?; + if winner.schema != ASSESSMENT_PROPOSAL_CACHE_SCHEMA + || winner.basis_digest != basis_digest + { + return Err(anyhow!( + "assessment proposal cache winner identity mismatch" + )); + } + selected_proposal = validate_and_bind_proposal( + winner.proposal.clone(), + campaign, + actor, + &allowed_references, + )?; + selected_receipt = cache_hit_receipt( + &winner, + &selected_proposal, + &snapshot_binding, + &base_prompt, + &campaign.branch_origin.evidence_receipt_ids, + )?; + } + } + let assessment = build_assessment(campaign, intent, selected_proposal)?; + Ok((assessment, selected_receipt)) } } +fn validate_and_bind_proposal( + mut proposal: AssessmentProposal, + campaign: &Campaign, + actor: &crate::domain::ActorState, + allowed_references: &BTreeSet, +) -> Result { + bind_visible_knowledge(&mut proposal)?; + validate_proposal(&proposal, allowed_references)?; + for (effect, stake) in [ + (&proposal.strong_effect, &proposal.success_stake), + (&proposal.success_effect, &proposal.success_stake), + (&proposal.mixed_effect, &proposal.mixed_stake), + (&proposal.failure_effect, &proposal.failure_stake), + ] { + validate_effect(campaign, actor, effect, stake)?; + } + Ok(proposal) +} + +fn build_assessment( + campaign: &Campaign, + intent: ActionIntent, + proposal: AssessmentProposal, +) -> Result { + let modifier_total = + crate::d20::capped_modifier(proposal.modifiers.iter().map(|modifier| modifier.value)); + let mut assessment = ActionAssessment { + schema: "ghostlight.player_action_assessment.v1".into(), + campaign_id: campaign.id, + revision: campaign.revision, + intent, + admissible: proposal.admissible, + missing_permission: proposal.missing_permission, + dc: proposal.dc, + modifiers: proposal.modifiers, + modifier_total, + effect_ceiling: proposal.effect_ceiling, + success_stake: proposal.success_stake, + mixed_stake: proposal.mixed_stake, + failure_stake: proposal.failure_stake, + strong_effect: proposal.strong_effect, + success_effect: proposal.success_effect, + mixed_effect: proposal.mixed_effect, + failure_effect: proposal.failure_effect, + bargains: proposal.bargains, + expires_at: Utc::now() + Duration::minutes(10), + digest: String::new(), + }; + assessment.digest = assessment_digest(&assessment)?; + Ok(assessment) +} + +fn assessment_basis_digest(model_id: &str, base_prompt: &str) -> String { + format!( + "sha256:{:x}", + Sha256::digest( + format!("{ASSESSMENT_SEMANTICS_VERSION}|{model_id}|{base_prompt}").as_bytes() + ) + ) +} + +fn cache_hit_receipt( + cached: &AssessmentProposalCacheEntry, + proposal: &AssessmentProposal, + snapshot_binding: &str, + base_prompt: &str, + source_receipt_ids: &[String], +) -> Result { + let output = serde_json::to_string(proposal)?; + let output_hash = format!("sha256:{:x}", Sha256::digest(output.as_bytes())); + let request_hash = format!( + "sha256:{:x}", + Sha256::digest( + format!( + "{}|{}|{}|{}", + cached.basis_digest, + snapshot_binding, + cached.source_model, + source_receipt_ids.join("|") + ) + .as_bytes() + ) + ); + let receipt_hash = format!( + "sha256:{:x}", + Sha256::digest( + format!( + "{}|{}|action_assessment|{}|{}|{}|{}", + cached.source_provider, + cached.source_model, + snapshot_binding, + request_hash, + output_hash, + cached.source_receipt_hash + ) + .as_bytes() + ) + ); + Ok(ModelStageReceipt { + schema: "ghostlight.persona_stage_receipt.v1".into(), + receipt_hash, + provider: cached.source_provider.clone(), + model: cached.source_model.clone(), + stage: "action_assessment".into(), + snapshot_binding: snapshot_binding.into(), + request_hash, + output_hash, + source_receipt_ids: source_receipt_ids.to_vec(), + latency_ms: 0, + validation_result: "valid_cache_hit".into(), + local_validation_error: None, + input_chars: base_prompt.chars().count(), + output_chars: output.chars().count(), + provider_attempts: vec![ModelProviderAttemptReceipt { + provider_request_id: None, + system_fingerprint: None, + finish_reason: Some("cache_hit".into()), + latency_ms: 0, + token_usage: Some(ModelTokenUsage::default()), + transport_features: vec![ + "cultcache.output-cache".into(), + format!("source-receipt:{}", cached.source_receipt_hash), + ], + local_validation_result: "valid_cache_hit".into(), + local_validation_error: None, + }], + }) +} + fn constrain_assessment_schema( schema: &mut serde_json::Value, allowed_references: &BTreeSet, @@ -742,6 +974,44 @@ pub fn assessment_digest(assessment: &ActionAssessment) -> Result { #[cfg(test)] mod tests { use super::*; + use async_trait::async_trait; + use std::sync::atomic::{AtomicUsize, Ordering}; + + struct DriftingAssessmentModel { + calls: AtomicUsize, + } + + #[async_trait] + impl ModelPort for DriftingAssessmentModel { + async fn run(&self, request: &ModelStageRequest) -> Result { + let call = self.calls.fetch_add(1, Ordering::SeqCst); + let mut value = serde_json::to_value(proposal("actor:player"))?; + value["modifiers"][0]["value"] = serde_json::json!(if call == 0 { 2 } else { 6 }); + let allowed_effect_fields = request + .output_schema + .as_ref() + .and_then(|schema| schema.pointer("/$defs/WorldEffectDelta/properties")) + .and_then(serde_json::Value::as_object) + .map(|properties| properties.keys().cloned().collect::>()) + .unwrap_or_default(); + for field in [ + "strong_effect", + "success_effect", + "mixed_effect", + "failure_effect", + ] { + value[field] + .as_object_mut() + .expect("fixture effect is an object") + .retain(|key, _| allowed_effect_fields.contains(key)); + } + Ok(serde_json::to_string(&value)?) + } + + fn provider(&self) -> &'static str { + "drifting-fixture" + } + } fn proposal(reference: &str) -> AssessmentProposal { AssessmentProposal { @@ -766,6 +1036,48 @@ mod tests { } } + #[tokio::test] + async fn unchanged_semantic_packet_reuses_exact_validated_assessment_proposal() { + let model = Arc::new(DriftingAssessmentModel { + calls: AtomicUsize::new(0), + }); + let assessor = ActionAssessor::new(model.clone(), "fixture-model"); + let dir = tempfile::tempdir().unwrap(); + let store = CampaignStore::open(dir.path().join("campaign.cc")).unwrap(); + let mut campaign = crate::resolution::tests::campaign(0, 1); + let intent = ActionIntent { + actor_id: "player".into(), + description: "inspect the gate".into(), + intended_effect: "learn whether it is open".into(), + }; + + let (first, first_receipt) = assessor + .assess_with_context_cached(&store, &campaign, intent.clone(), &[], None, &[]) + .await + .unwrap(); + campaign.revision += 1; + let (second, second_receipt) = assessor + .assess_with_context_cached(&store, &campaign, intent, &[], None, &[]) + .await + .unwrap(); + + assert_eq!(model.calls.load(Ordering::SeqCst), 1); + assert_eq!(first.modifiers, second.modifiers); + assert_eq!(first.modifier_total, 2); + assert_eq!(second.modifier_total, 2); + assert_eq!(first.revision, 0); + assert_eq!(second.revision, 1); + assert_ne!(first.digest, second.digest); + assert_eq!(first_receipt.validation_result, "valid"); + assert_eq!(second_receipt.validation_result, "valid_cache_hit"); + assert!( + second_receipt.provider_attempts[0] + .transport_features + .contains(&"cultcache.output-cache".to_string()) + ); + assert_eq!(store.keys(ASSESSMENT_PROPOSAL_CACHE_KIND).unwrap().len(), 1); + } + #[test] fn assessment_rejects_unearned_state_reference() { let allowed = BTreeSet::from(["equipment:key".into()]); diff --git a/crates/ghostlight-dungeon/src/main.rs b/crates/ghostlight-dungeon/src/main.rs index a56ab66..1cdc624 100644 --- a/crates/ghostlight-dungeon/src/main.rs +++ b/crates/ghostlight-dungeon/src/main.rs @@ -1797,8 +1797,45 @@ fn transient_result_projection( .get("admissible") .and_then(serde_json::Value::as_bool) .unwrap_or(false); + let modifier_details = assessment + .get("modifiers") + .and_then(serde_json::Value::as_array) + .map(|modifiers| { + if modifiers.is_empty() { + "Modifiers: none".to_string() + } else { + let lines = modifiers + .iter() + .map(|modifier| { + let label = modifier + .get("label") + .and_then(serde_json::Value::as_str) + .unwrap_or("context"); + let value = modifier + .get("value") + .and_then(serde_json::Value::as_i64) + .unwrap_or(0); + let references = modifier + .get("references") + .and_then(serde_json::Value::as_array) + .into_iter() + .flatten() + .filter_map(serde_json::Value::as_str) + .collect::>(); + if references.is_empty() { + format!("- {value:+} {label}") + } else { + format!("- {value:+} {label} [{}]", references.join(", ")) + } + }) + .collect::>() + .join("\n"); + format!("Modifiers:\n{lines}") + } + }) + .unwrap_or_else(|| "Modifiers: none".into()); let summary = format!( - "{}\nDC {} · modifier {} · ceiling {}\nSuccess: {}\nMixed: {}\nFailure: {}{}", + "{}\nDC {} · modifier {} · ceiling {}\n{}\nSuccess: {}\nMixed: {}\nFailure: {}{}", if admissible { "The attempt is admissible." } else { @@ -1816,6 +1853,7 @@ fn transient_result_projection( .get("effect_ceiling") .and_then(serde_json::Value::as_str) .unwrap_or("bounded"), + modifier_details, assessment .get("success_stake") .and_then(serde_json::Value::as_str) @@ -3880,7 +3918,8 @@ async fn resolve_npc_initiative( }) .unwrap_or_default(); let (assessment, receipt) = assessor - .assess_with_context( + .assess_with_context_cached( + &runtime.store, campaign, intent, &permissions, @@ -4374,7 +4413,8 @@ async fn command( .unwrap_or_default(); let (contract, boundaries) = campaign_model_policy(&runtime.store, campaign.id); match assessor - .assess_with_context( + .assess_with_context_cached( + &runtime.store, &campaign, intent.clone(), &extraordinary_permissions, @@ -4675,7 +4715,8 @@ async fn command( .unwrap_or_default(); let (contract, boundaries) = campaign_model_policy(&runtime.store, campaign.id); match assessor - .assess_with_context( + .assess_with_context_cached( + &runtime.store, &campaign, intent.clone(), &permissions, @@ -6771,6 +6812,13 @@ mod tests { "admissible": true, "dc": 15, "modifier_total": 2, + "modifiers": [ + { + "label":"The audit seal matches the lock", + "value":2, + "references":["equipment:audit-seal","location:archive"] + } + ], "effect_ceiling": "Supervised access only", "success_stake": "The ledger is opened.", "mixed_stake": "The ledger is opened under scrutiny.", @@ -6790,6 +6838,11 @@ mod tests { roll["props"]["action"]["assessment_digest"], "sha256:fresh-assessment" ); + let summary = projection["surface"]["root"]["children"][0]["props"]["value"] + .as_str() + .unwrap(); + assert!(summary.contains("+2 The audit seal matches the lock")); + assert!(summary.contains("equipment:audit-seal, location:archive")); } #[test] diff --git a/docs/architecture/ghostlight-dungeon-mvp.md b/docs/architecture/ghostlight-dungeon-mvp.md index b23f8ed..b88f881 100644 --- a/docs/architecture/ghostlight-dungeon-mvp.md +++ b/docs/architecture/ghostlight-dungeon-mvp.md @@ -621,6 +621,21 @@ actors, supplied institutions, accessible facts, branch evidence, and accepted extraordinary permissions. A remote actor is not a valid modifier reference. The same set is shown to the assessor and enforced by local validation, so a model cannot invent a reference namespace or cite context it was not given. +The player projection lists every modifier label, signed value, and exact +supporting reference rather than exposing only the capped total. + +The validated semantic proposal is content-addressed by the exact model, +instructions, action-specific schema, and permitted typed state packet. Its +private `assessment_proposal_cache.v1` row is derived inference evidence, not an +assessment or world authority. Campaign revision and expiry remain commit +bindings but are absent from this semantic identity. A stale confirmation whose +permitted packet is unchanged therefore reuses the byte-identical validated DC, +modifiers, stakes, and outcome deltas, locally revalidates them, and issues a +new revision-bound assessment digest without provider inference. Any change to +the model contract, schema, actor slice, occupancy, facts, institutions, +permissions, campaign contract, or boundaries changes the content address and +requires a fresh assessment. Cache hits emit an explicit zero-token model-stage +receipt pointing at the originating receipt. Outcome-delta maps are bound to the same snapshot rather than accepting a free-form identifier namespace. Actor effects may name only co-located actors; diff --git a/notes/ghostlight-current-system-map.md b/notes/ghostlight-current-system-map.md index b220b37..d3e8ea2 100644 --- a/notes/ghostlight-current-system-map.md +++ b/notes/ghostlight-current-system-map.md @@ -969,6 +969,16 @@ committed source turn. A missing directly addressed Persona or a null response aborts the whole wave without private deltas, transcript additions, initiative, or revision change; observers may still choose to speak from their own goals. +Action assessment separates semantic inference identity from commit identity. +The exact model, stable instructions, action-specific schema, and permitted +typed packet form a content-addressed private `assessment_proposal_cache.v1` +key. Revision and expiry still bind the consumable assessment and roll but do +not force the capable model to reconsider an otherwise byte-identical packet. +A cache hit revalidates the complete proposal against current state, emits a +zero-token receipt linked to the source receipt, and creates a fresh digest at +the current revision. Changed authority changes the key. The Eve command-result +projection shows every signed modifier with its exact references. + Population fission now composes admitted child entities, stable child identities, one lineage split, exact resource custody transfers, and exact named-member membership transfers. The old fission function that directly diff --git a/state/map.yaml b/state/map.yaml index 4579849..b21c049 100644 --- a/state/map.yaml +++ b/state/map.yaml @@ -76,6 +76,8 @@ live_architecture: - The mutation reducer validates a complete batch against an exact authority envelope on an isolated component overlay, advances each touched subject version once, and persists component state, authority, batch, mutation receipt, causal receipt, events, and aggregate compatibility projection atomically. Aggregate campaign rows are rejected by component-only mutation ingress. - WorldEffectDelta, ActorStateDelta, and StrategicOutcomeEffect are model-boundary migration inputs, not independent writers. Bounded region expansion lowers through typed place/proposition admission and topology mutations. Initial publication is a fresh-store creation transaction; named-person materialisation/folding is a resolution transaction that advances revision and resolution epoch, clears the cover, preserves the individual delta, and cannot rewrite Gestalt-wide knowledge, custody, pressure, or fictional time. - Ghostlight owns generalized Projector to Persona to Interpreter machinery; consuming Personas retain their own canonical minds and commit authority. + - Player speech address is a bounded proposal over exact co-present simulation-eligible actor IDs. WorldKernel commits the selected Persona response set with the speech turn; every present actor still appraises, while direct addressees receive explicit response duty and observers retain optional agency. A direct addressee must speak or select typed deliberate silence, which lowers deterministically rather than opening a free-text reaction-effect lane. + - Action assessment semantic proposals are content-addressed by the exact model, stable instructions, action-specific schema, and permitted typed packet. Private CultCache cache rows are derived inference evidence only. Revision and expiry bind the consumable assessment and roll but do not invalidate an otherwise identical semantic proposal; cache hits revalidate it, emit an explicit zero-token receipt linked to the source receipt, and issue a fresh revision-bound digest. Changed actor state, occupancy, facts, institutions, permissions, contract, boundaries, schema, or model contract changes the key. Eve projections itemize every signed modifier and exact reference. - The hosted player story is the chronological lowering of exact committed NarrativeTurn rows. No narrator or verifier model rewrites those turns; historical narration projections are inert and never enter Eve or CultMesh player surfaces. - Epiphany consumes the extracted Ghostlight projection crate at an exact Git revision while retaining her canonical Mind, effect admission, and consequence authority. - Gestalt Personas own shared population state; first-relevance individuation and later folding are revisioned WorldKernel commits, and durable member deltas preserve specific people between appearances. @@ -308,5 +310,5 @@ data_flow: current_status: summary: Yggdrasil serves immutable Ghostlight release 447f4027c37f13c83afb4431421d8d66b9384bcd with Eve 19c3dcf9173dce848a6253e975324ea239a02d24, daemon SHA-256 084e01d22453d0c99c9fe2b375aeead455a970139b0cc8f0f1e1f38c87086d0f, native-client SHA-256 d3f49d2b5459ace468af0c75a02052e099ffc086f9a88b6937b0a49dc67199cd, and artifact sha256-d8f944778c09d0696bc1bd76dc94e613c448053416f5300f0870a968496757cc. Idunn's locked 265-test Linux package gate, release and web builds, active symlink, signed health, zero-restart daemon, DeepSeek readiness, HTTP listener, and loopback-only native RUDP listener agree. Odin returns the provider advertisement with the redacted `ghostlight.native.player` boundary; its smoke must dial Odin at 10.77.0.1:17871 because 127.0.0.1:17871 is Idunn. A forged native session returned the canonical denial receipt while every campaign-store digest remained unchanged. A pressure run exposed that repeated `auth-begin` could orphan a completed Heimdall attempt by replacing the client's only pending handle. The live client now refuses overwrite, clears terminal owned attempts, and can recover an exact completed handle through stdin without placing it in arguments or output. Heimdall begin and completion retain their existing authority. One clean native Discord attempt is currently pending; after redemption, the client will keep only the resulting Ghostlight app-session bearer in private CultCache and server-side refresh will preserve the grant between launches. Existing mutation, Gestalt, topology, knowledge, privacy, no-puppeting, and atomicity invariants remain authoritative. Starfire remains retired as a writer. - next_action: Complete one Heimdall OAuth grant for the native client, fetch the actor-filtered `ghostlight.play` surface directly over CultMesh, and resume adversarial homepage-promise play through canonical Eve invocations without the browser. Repair the first world/compiler/agency invariant failure at its owning kernel or projection seam. Then pressure the 20-plus-power Aetheria skeleton and nested refugee continuity across budgets 1, 4, 8, and 32. Separately grow the 36-case agency corpus toward 300 reviewed cases and close multi-account co-op proof. Preserve the revision-12 Mira movement scar as history; do not weaken actor, privacy, approval, atomicity, or no-puppeting invariants. + next_action: Finish Idunn deployment of the exact speech-address cut, replay the two-refugee memory challenge through the authenticated native CultMesh client, and verify exact separate replies plus observer restraint in canonical state. Then continue adversarial homepage-promise play, pressure the 20-plus-power Aetheria skeleton and nested refugee continuity across budgets 1, 4, 8, and 32, grow the 36-case agency corpus toward 300 reviewed cases, and close multi-account co-op proof. Preserve the revision-12 Mira movement scar as history; do not weaken actor, privacy, approval, atomicity, or no-puppeting invariants. gestalt_population: Gestalt Personas own shared population baselines; persistent member deltas own named individuality; WorldKernel materialization and approval-gated fission preserve lineage and identity. Materialisation/folding changes only representation and the exact member delta, advances resolution epoch, and retires the old cover; it has no Gestalt-wide effect authority. Selected actionable member exceptions are mandatory Projector perspective owners, so aggregation cannot silently erase their decision. Presence projection is limited to nearby active leaves and exact-location dormant members, includes reciprocal player relationship evidence, and may propose an earned cast without committing it. Simulation cells are derived covers only.