From 2f7c0903ff0a3c6edee65af47304876ac11e4054 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Thu, 27 Aug 2026 09:29:47 +0200 Subject: [PATCH] Keep newspaper rejection outside world authority --- .../src/bin/ghostlight-strategic-smoke.rs | 174 ++++++++++++++---- crates/ghostlight-dungeon/src/persistence.rs | 32 ++++ crates/ghostlight-dungeon/src/registry.rs | 53 ++---- notes/ghostlight-current-system-map.md | 15 +- 4 files changed, 191 insertions(+), 83 deletions(-) diff --git a/crates/ghostlight-dungeon/src/bin/ghostlight-strategic-smoke.rs b/crates/ghostlight-dungeon/src/bin/ghostlight-strategic-smoke.rs index 135f5ef..4f91766 100644 --- a/crates/ghostlight-dungeon/src/bin/ghostlight-strategic-smoke.rs +++ b/crates/ghostlight-dungeon/src/bin/ghostlight-strategic-smoke.rs @@ -190,21 +190,56 @@ async fn main() -> anyhow::Result<()> { 5, &store, ) - .await?; - let issue_path = root.join(format!("newspaper-wave-{wave_index:02}.md")); - let issue_audit_path = root.join(format!("newspaper-wave-{wave_index:02}.audit.md")); - std::fs::write( - &issue_path, - ghostlight_dungeon::newspaper::render_world_newspaper_markdown( - &issue_composition.issue, - ), - )?; - std::fs::write( - &issue_audit_path, - ghostlight_dungeon::newspaper::render_world_newspaper_audit_markdown( - &issue_composition.issue, - ), - )?; + .await; + let ( + issue, + newspaper_grounding, + newspaper_model_receipts, + issue_path, + issue_audit_path, + newspaper_error, + ) = match issue_composition { + Ok(composition) => { + let issue_path = root.join(format!("newspaper-wave-{wave_index:02}.md")); + let issue_audit_path = + root.join(format!("newspaper-wave-{wave_index:02}.audit.md")); + std::fs::write( + &issue_path, + ghostlight_dungeon::newspaper::render_world_newspaper_markdown( + &composition.issue, + ), + )?; + std::fs::write( + &issue_audit_path, + ghostlight_dungeon::newspaper::render_world_newspaper_audit_markdown( + &composition.issue, + ), + )?; + ( + Some(composition.issue), + Some(composition.grounding), + composition.model_receipts, + Some(issue_path), + Some(issue_audit_path), + None, + ) + } + Err(error) => { + let Some(failure) = error.downcast_ref::< + ghostlight_dungeon::newspaper::WorldNewspaperCompositionFailure, + >() else { + return Err(error); + }; + ( + None, + None, + failure.model_receipts.clone(), + None::, + None::, + Some(error.to_string()), + ) + } + }; wave_reports.push(serde_json::json!({ "wave_index":wave_index, "elapsed_seconds":started.elapsed().as_secs_f64(), @@ -215,9 +250,10 @@ async fn main() -> anyhow::Result<()> { "rejected_pulses":rejected_pulses, "plan":plan, "commit":committed, - "issue":issue_composition.issue, - "newspaper_grounding":issue_composition.grounding, - "newspaper_model_receipts":issue_composition.model_receipts, + "issue":issue, + "newspaper_grounding":newspaper_grounding, + "newspaper_model_receipts":newspaper_model_receipts, + "newspaper_error":newspaper_error, "issue_path":issue_path, "issue_audit_path":issue_audit_path, })); @@ -236,7 +272,20 @@ async fn main() -> anyhow::Result<()> { }))?, )?; } - let newspaper_composition = compose_persisted_newspaper( + let first_plan = wave_reports[0]["plan"].clone(); + let first_commit = wave_reports[0]["commit"].clone(); + let first_model_receipt_hash = wave_reports[0]["model_receipt_hash"].clone(); + let model_stage_receipts = wave_reports + .iter() + .flat_map(|wave| { + wave["model_stage_receipts"] + .as_array() + .into_iter() + .flatten() + .cloned() + }) + .collect::>(); + let newspaper_composition = match compose_persisted_newspaper( model.as_ref(), &campaign, &newspaper_title, @@ -244,7 +293,55 @@ async fn main() -> anyhow::Result<()> { 6, &store, ) - .await?; + .await + { + Ok(composition) => composition, + Err(error) => { + let final_newspaper_model_receipts = error + .downcast_ref::() + .map(|failure| failure.model_receipts.clone()) + .unwrap_or_default(); + let failed_result = serde_json::json!({ + "schema":"ghostlight.live_strategic_smoke_failure.v1", + "scenario_id":scenario_id, + "pressure":pressure, + "wave_count":wave_count, + "campaign_id":campaign.id, + "elapsed_seconds":started.elapsed().as_secs_f64(), + "model_runtime":model_selection.status("configured"), + "model_receipt_hash":&first_model_receipt_hash, + "model_stage_receipts":&model_stage_receipts, + "plan":&first_plan, + "commit":&first_commit, + "waves":&wave_reports, + "event_count":campaign.events.len(), + "news_count":campaign.news.len(), + "final_newspaper_error":error.to_string(), + "final_newspaper_model_receipts":final_newspaper_model_receipts, + "player_location_unchanged":true, + "player_state_unchanged":true, + "store":root.join("campaign.cc") + }); + let result_path = root.join("result.json"); + std::fs::write(&result_path, serde_json::to_vec_pretty(&failed_result)?)?; + std::fs::write( + root.join("status.json"), + serde_json::to_vec_pretty(&serde_json::json!({ + "schema":"ghostlight.live_strategic_smoke_status.v1", + "state":"failed", + "waves_completed":wave_count, + "waves_requested":wave_count, + "world_revision":campaign.revision, + "event_count":campaign.events.len(), + "news_count":campaign.news.len(), + "updated_at":Utc::now(), + "result_path":result_path, + "newspaper_error":error.to_string(), + }))?, + )?; + return Err(error); + } + }; let newspaper_path = root.join("newspaper.md"); let newspaper_audit_path = root.join("newspaper.audit.md"); std::fs::write( @@ -259,19 +356,6 @@ async fn main() -> anyhow::Result<()> { &newspaper_composition.issue, ), )?; - let first_plan = wave_reports[0]["plan"].clone(); - let first_commit = wave_reports[0]["commit"].clone(); - let first_model_receipt_hash = wave_reports[0]["model_receipt_hash"].clone(); - let model_stage_receipts = wave_reports - .iter() - .flat_map(|wave| { - wave["model_stage_receipts"] - .as_array() - .into_iter() - .flatten() - .cloned() - }) - .collect::>(); let result = serde_json::json!({ "schema":"ghostlight.live_strategic_smoke.v3", "scenario_id":scenario_id, @@ -342,13 +426,23 @@ async fn compose_persisted_newspaper( .map(|failure| failure.model_receipts.as_slice()), }; if let Some(receipts) = receipts { - for receipt in receipts { - store.insert( - "persona_stage_receipt.v1", - "ghostlight.persona_stage_receipt.v1", - receipt.storage_key(), - receipt, - )?; + if let Err(persistence_error) = store.persist_model_stage_receipts(receipts) { + if let Err(error) = &result + && let Some(failure) = error.downcast_ref::< + ghostlight_dungeon::newspaper::WorldNewspaperCompositionFailure, + >() + { + return Err(anyhow::Error::new( + ghostlight_dungeon::newspaper::WorldNewspaperCompositionFailure { + message: format!( + "{}; model-receipt persistence failed: {persistence_error}", + failure.message + ), + model_receipts: failure.model_receipts.clone(), + }, + )); + } + return Err(persistence_error); } } result diff --git a/crates/ghostlight-dungeon/src/persistence.rs b/crates/ghostlight-dungeon/src/persistence.rs index 761a25f..63fcb03 100644 --- a/crates/ghostlight-dungeon/src/persistence.rs +++ b/crates/ghostlight-dungeon/src/persistence.rs @@ -7,6 +7,7 @@ use crate::domain::{ ResolutionWaveCommit, StrategicTickReceipt, VaultEvidenceReceipt, VaultManifest, WorldCommitReceipt, }; +use crate::model::ModelStageReceipt; use crate::session_zero::{ CellBudgetProposal, GroupTravelProposal, PublishedSessionZeroSeed, TimeAdvanceProposal, }; @@ -88,6 +89,37 @@ impl CampaignStore { Ok(row) } + pub fn persist_model_stage_receipts(&self, receipts: &[ModelStageReceipt]) -> Result<()> { + for receipt in receipts { + if let Some((_, existing)) = + self.load::("persona_stage_receipt.v1", receipt.storage_key())? + { + if existing.same_receipted_content(receipt) { + continue; + } + return Err(anyhow!( + "immutable model-stage receipt conflict: {}", + receipt.storage_key() + )); + } + let inserted = self.insert( + "persona_stage_receipt.v1", + "ghostlight.persona_stage_receipt.v1", + receipt.storage_key(), + receipt, + ); + if let Err(error) = inserted { + let repeated = self + .load::("persona_stage_receipt.v1", receipt.storage_key())? + .is_some_and(|(_, existing)| existing.same_receipted_content(receipt)); + if !repeated { + return Err(error); + } + } + } + Ok(()) + } + pub fn create_component_world_state( &self, state: &ComponentWorldState, diff --git a/crates/ghostlight-dungeon/src/registry.rs b/crates/ghostlight-dungeon/src/registry.rs index 4975216..87d7b69 100644 --- a/crates/ghostlight-dungeon/src/registry.rs +++ b/crates/ghostlight-dungeon/src/registry.rs @@ -420,11 +420,24 @@ impl CampaignRegistry { if let Err(error) = &composition_result && let Some(failure) = error.downcast_ref::() + && let Err(persistence_error) = runtime + .store + .persist_model_stage_receipts(&failure.model_receipts) { - persist_newspaper_model_receipts(&runtime, &failure.model_receipts)?; + return Err(anyhow::Error::new( + crate::newspaper::WorldNewspaperCompositionFailure { + message: format!( + "{}; model-receipt persistence failed: {persistence_error}", + failure.message + ), + model_receipts: failure.model_receipts.clone(), + }, + )); } let composition = composition_result?; - persist_newspaper_model_receipts(&runtime, &composition.model_receipts)?; + runtime + .store + .persist_model_stage_receipts(&composition.model_receipts)?; Ok(composition.issue) } @@ -655,42 +668,6 @@ impl CampaignRegistry { } } -fn persist_newspaper_model_receipts( - runtime: &CampaignRuntime, - receipts: &[ModelStageReceipt], -) -> Result<()> { - for receipt in receipts { - if let Some((_, existing)) = runtime - .store - .load::("persona_stage_receipt.v1", receipt.storage_key())? - { - if existing.same_receipted_content(receipt) { - continue; - } - return Err(anyhow!( - "immutable newspaper model receipt conflict: {}", - receipt.storage_key() - )); - } - let inserted = runtime.store.insert( - "persona_stage_receipt.v1", - "ghostlight.persona_stage_receipt.v1", - receipt.storage_key(), - receipt, - ); - if let Err(error) = inserted { - let repeated = runtime - .store - .load::("persona_stage_receipt.v1", receipt.storage_key())? - .is_some_and(|(_, existing)| existing.same_receipted_content(receipt)); - if !repeated { - return Err(error); - } - } - } - Ok(()) -} - fn cleanup_staging_directory(root: &Path, staging: &Path) { let safe = staging.parent() == Some(root) && staging diff --git a/notes/ghostlight-current-system-map.md b/notes/ghostlight-current-system-map.md index be8777c..b9f87cf 100644 --- a/notes/ghostlight-current-system-map.md +++ b/notes/ghostlight-current-system-map.md @@ -948,11 +948,16 @@ issue time is derived from the latest cited publication record without exposing that clock to editorial inference. Terminally rejected attempts semantically rebind their otherwise immutable model receipts to a collision-free invalid disposition and return a typed failure carrying every completed receipt. The -registry persists those receipts idempotently before returning the rejection. -The reader renderer has no path to provenance fields and escapes all model- and -consumer-supplied plain text before Markdown emission; the provenance renderer -applies the same plain-text boundary to its audit data. Neither editor, copy -desk, renderer, nor registry receipt persistence can write world state. +campaign store owns idempotent model-receipt persistence; the registry and +strategic acceptance smoke use that same primitive before returning a +rejection. In the acceptance smoke, an interim edition rejection is local to +the consumer and cannot stop later world waves. A rejected final combined +edition remains a nonzero acceptance failure, but first writes the completed +wave reports, rejection receipts, and failed status. The reader renderer has no +path to provenance fields and escapes all model- and consumer-supplied plain +text before Markdown emission; the provenance renderer applies the same +plain-text boundary to its audit data. Neither editor, copy desk, renderer, nor +receipt persistence can write world state. Session Zero compilation, expansion, and fission follow the same projection rule. Review projections expose topology, pressures, source-use coverage, gaps,