Build persistent world action loops

This commit is contained in:
Meta Vens 2026-08-16 20:36:01 +02:00
commit 2b825cacb9
20 changed files with 1816 additions and 33 deletions

View file

@ -0,0 +1,205 @@
use crate::{
domain::{ActionAssessment, ActionIntent, Campaign, ContextModifier},
model::{ModelPort, ModelStageReceipt, ModelStageRequest, run_validated_stage},
};
use anyhow::{Result, anyhow};
use chrono::{Duration, Utc};
use schemars::{JsonSchema, schema_for};
use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha256};
use std::{collections::BTreeSet, sync::Arc};
#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
struct AssessmentProposal {
normalized_intent: String,
admissible: bool,
missing_permission: Option<String>,
dc: u8,
modifiers: Vec<ContextModifier>,
effect_ceiling: String,
success_stake: String,
mixed_stake: String,
failure_stake: String,
bargains: Vec<String>,
}
pub struct ActionAssessor {
model: Arc<dyn ModelPort>,
model_id: String,
}
impl ActionAssessor {
pub fn new(model: Arc<dyn ModelPort>, model_id: impl Into<String>) -> Self {
Self {
model,
model_id: model_id.into(),
}
}
pub async fn assess(
&self,
campaign: &Campaign,
intent: ActionIntent,
) -> Result<(ActionAssessment, ModelStageReceipt)> {
let actor = campaign
.actors
.get(&intent.actor_id)
.ok_or_else(|| anyhow!("actor does not exist in this branch"))?;
let location = campaign
.locations
.get(&actor.location_id)
.ok_or_else(|| anyhow!("actor location is invalid"))?;
let visible_institutions: Vec<_> = campaign
.institutions
.values()
.map(|x| serde_json::json!({"id":x.id,"name":x.name,"posture":x.posture}))
.collect();
let allowed_references = allowed_references(campaign, actor);
let schema = serde_json::to_value(schema_for!(AssessmentProposal))?;
let prompt = format!(
"Assess an attempted effect, not whether words can be spoken. Impossible actions are inadmissible and receive bargains, not a roll. Choose DC only from 5,10,15,20,25,30. Every modifier reference must be copied exactly from ALLOWED REFERENCES. Modifier total is capped at +/-10. Never grant capability, custody, access, knowledge, or spatial reach absent from state. State concrete success, mixed, and failure consequences and a bounded effect ceiling.\nINTENT:\n{}\nACTOR:\n{}\nLOCATION:\n{}\nVISIBLE INSTITUTIONS:\n{}\nALLOWED REFERENCES:\n{}\nOUTPUT JSON SCHEMA:\n{}",
serde_json::to_string(&intent)?,
serde_json::to_string(actor)?,
serde_json::to_string(location)?,
serde_json::to_string(&visible_institutions)?,
serde_json::to_string(&allowed_references)?,
serde_json::to_string_pretty(&schema)?
);
let out = run_validated_stage(
self.model.as_ref(),
&ModelStageRequest {
stage: "action_assessment".into(),
model: self.model_id.clone(),
snapshot_binding: format!(
"campaign:{}:revision:{}",
campaign.id, campaign.revision
),
lived_stream: prompt,
output_schema: Some(schema),
source_receipt_ids: campaign.branch_origin.evidence_receipt_ids.clone(),
},
)
.await?;
let proposal: AssessmentProposal = serde_json::from_value(
out.structured
.ok_or_else(|| anyhow!("assessor returned no typed proposal"))?,
)?;
validate_proposal(&proposal, &allowed_references)?;
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,
bargains: proposal.bargains,
expires_at: Utc::now() + Duration::minutes(10),
digest: String::new(),
};
assessment.digest = assessment_digest(&assessment)?;
Ok((assessment, out.receipt))
}
}
fn allowed_references(campaign: &Campaign, actor: &crate::domain::ActorState) -> BTreeSet<String> {
let mut refs = BTreeSet::from([
format!("actor:{}", actor.id),
format!("location:{}", actor.location_id),
]);
for value in actor
.capabilities
.iter()
.map(|x| format!("capability:{x}"))
.chain(actor.knowledge.iter().map(|x| format!("knowledge:{x}")))
.chain(actor.equipment.iter().map(|x| format!("equipment:{x}")))
.chain(actor.conditions.iter().map(|x| format!("condition:{x}")))
.chain(actor.obligations.iter().map(|x| format!("obligation:{x}")))
{
refs.insert(value);
}
for id in campaign.institutions.keys() {
refs.insert(format!("institution:{id}"));
}
for id in campaign.facts.keys() {
refs.insert(format!("fact:{id}"));
}
for id in &campaign.branch_origin.evidence_receipt_ids {
refs.insert(id.clone());
}
refs
}
fn validate_proposal(p: &AssessmentProposal, allowed: &BTreeSet<String>) -> Result<()> {
if ![5, 10, 15, 20, 25, 30].contains(&p.dc) {
return Err(anyhow!("assessor chose invalid DC"));
}
if p.modifiers
.iter()
.any(|m| m.value < -10 || m.value > 10 || m.references.iter().any(|r| !allowed.contains(r)))
{
return Err(anyhow!(
"assessor used an invalid modifier or unearned reference"
));
}
if p.admissible && p.missing_permission.is_some() {
return Err(anyhow!("admissible assessment claims missing permission"));
}
if !p.admissible && p.missing_permission.is_none() {
return Err(anyhow!(
"inadmissible assessment omitted missing permission"
));
}
Ok(())
}
pub fn assessment_digest(assessment: &ActionAssessment) -> Result<String> {
let mut value = assessment.clone();
value.digest.clear();
Ok(format!(
"sha256:{:x}",
Sha256::digest(rmp_serde::to_vec_named(&value)?)
))
}
#[cfg(test)]
mod tests {
use super::*;
fn proposal(reference: &str) -> AssessmentProposal {
AssessmentProposal {
normalized_intent: "open the gate".into(),
admissible: true,
missing_permission: None,
dc: 15,
modifiers: vec![ContextModifier {
label: "tool".into(),
value: 2,
references: vec![reference.into()],
}],
effect_ceiling: "open this gate".into(),
success_stake: "gate opens".into(),
mixed_stake: "gate opens noisily".into(),
failure_stake: "lock jams".into(),
bargains: vec![],
}
}
#[test]
fn assessment_rejects_unearned_state_reference() {
let allowed = BTreeSet::from(["equipment:key".into()]);
assert!(validate_proposal(&proposal("capability:telepathy"), &allowed).is_err());
assert!(validate_proposal(&proposal("equipment:key"), &allowed).is_ok());
}
#[test]
fn assessment_rejects_noncanonical_dc() {
let mut value = proposal("equipment:key");
value.dc = 17;
assert!(validate_proposal(&value, &BTreeSet::from(["equipment:key".into()])).is_err());
}
}

View file

@ -100,6 +100,13 @@ struct CompiledSeed {
opening_narration: String,
}
#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
struct CompiledExpansionSeed {
locations: Vec<Location>,
facts: Vec<WorldFact>,
gaps: Vec<String>,
}
pub struct WorldCompiler {
vault: Arc<dyn VaultProvider>,
model: Arc<dyn ModelPort>,
@ -209,6 +216,77 @@ impl WorldCompiler {
.await
}
pub async fn compile_destination(
&self,
campaign: &Campaign,
origin_location_id: &str,
destination_request: &str,
) -> Result<(crate::domain::RegionExpansionPreview, ModelStageReceipt)> {
let origin = campaign
.locations
.get(origin_location_id)
.ok_or_else(|| anyhow!("origin location is unknown"))?;
let queries = [
format!(
"{} {} geography containment routes",
origin.name, destination_request
),
format!("{} travel time institutions access", destination_request),
];
let receipts = self
.retrieve_all(&queries, &campaign.branch_origin.canon_cutoff, 10)
.await?;
let output=self.structured("destination_compile",&format!("campaign:{}:revision:{}",campaign.id,campaign.revision),&format!("Compile only the requested bounded destination region. Every new location id must be new. At least one new location must route back to origin id {} with a positive travel time. Do not rewrite existing geography. CAMPAIGN LOCATIONS:\n{}\nREQUEST:\n{}\nEVIDENCE:\n{}",origin_location_id,serde_json::to_string(&campaign.locations)?,destination_request,evidence_text(&receipts)),serde_json::to_value(schema_for!(CompiledExpansionSeed))?,receipt_ids(&receipts)).await?;
let seed: CompiledExpansionSeed = serde_json::from_value(output.0)?;
let evidence_ids = receipt_ids(&receipts);
let affected_sources: Vec<String> = receipts
.iter()
.flat_map(|r| r.witnesses.iter().map(|w| w.source_id.clone()))
.collect::<BTreeSet<_>>()
.into_iter()
.collect();
let candidates = seed
.gaps
.iter()
.enumerate()
.map(|(index, gap)| crate::domain::CanonCandidate {
schema: "ghostlight.canon_candidate.v1".into(),
id: format!(
"canon-candidate:{}:r{}:{}",
campaign.id,
campaign.revision,
index + 1
),
originating_campaign_id: campaign.id,
gap: gap.clone(),
evidence_receipt_ids: evidence_ids.clone(),
conflicts: vec![],
proposed_wording: format!("Clarify the documented answer to: {gap}"),
affected_vault_sources: affected_sources.clone(),
status: "review".into(),
})
.collect();
let expansion = crate::domain::RegionExpansion {
origin_location_id: origin_location_id.into(),
locations: seed.locations,
facts: seed.facts,
};
validate_region_expansion(campaign, &expansion)?;
Ok((
crate::domain::RegionExpansionPreview {
schema: "ghostlight.region_expansion_preview.v1".into(),
campaign_id: campaign.id,
expected_revision: campaign.revision,
expansion,
evidence_receipts: receipts,
gaps: seed.gaps,
canon_candidates: candidates,
requires_approval: true,
},
output.1,
))
}
async fn retrieve_all(
&self,
queries: &[String],
@ -266,6 +344,46 @@ impl WorldCompiler {
}
}
pub fn validate_region_expansion(
campaign: &Campaign,
expansion: &crate::domain::RegionExpansion,
) -> Result<()> {
if !campaign
.locations
.contains_key(&expansion.origin_location_id)
{
return Err(anyhow!("destination expansion origin is unknown"));
}
let new_ids: BTreeSet<_> = expansion.locations.iter().map(|x| x.id.as_str()).collect();
if expansion.locations.is_empty() || new_ids.len() != expansion.locations.len() {
return Err(anyhow!("destination expansion has no unique locations"));
}
if new_ids
.iter()
.any(|id| campaign.locations.contains_key(*id))
{
return Err(anyhow!(
"destination expansion collides with stable topology"
));
}
let known = |id: &str| campaign.locations.contains_key(id) || new_ids.contains(id);
let mut attached = false;
for location in &expansion.locations {
for route in location.routes.values() {
if route.travel_minutes == 0 || !known(&route.destination_id) {
return Err(anyhow!("destination expansion has a dangling route"));
}
if route.destination_id == expansion.origin_location_id {
attached = true;
}
}
}
if !attached {
return Err(anyhow!("destination expansion is not attached to origin"));
}
Ok(())
}
fn evidence_text(receipts: &[VaultEvidenceReceipt]) -> String {
receipts
.iter()
@ -309,6 +427,32 @@ fn seed_to_campaign(seed: CompiledSeed, receipts: &[VaultEvidenceReceipt]) -> Re
if actors.insert(player_id.clone(), seed.player).is_some() {
return Err(anyhow!("player id duplicates an NPC"));
}
let evidence_receipt_ids = receipt_ids(receipts);
let affected_sources: Vec<String> = receipts
.iter()
.flat_map(|r| r.witnesses.iter().map(|w| w.source_id.clone()))
.collect::<BTreeSet<_>>()
.into_iter()
.collect();
let canon_candidates = seed
.gaps
.iter()
.enumerate()
.map(|(index, gap)| {
let candidate = crate::domain::CanonCandidate {
schema: "ghostlight.canon_candidate.v1".into(),
id: format!("canon-candidate:{}:{}", id, index + 1),
originating_campaign_id: id,
gap: gap.clone(),
evidence_receipt_ids: evidence_receipt_ids.clone(),
conflicts: vec![],
proposed_wording: format!("Clarify the documented answer to: {gap}"),
affected_vault_sources: affected_sources.clone(),
status: "review".into(),
};
(candidate.id.clone(), candidate)
})
.collect();
Ok(Campaign {
schema: "ghostlight.campaign.v1".into(),
id,
@ -316,7 +460,7 @@ fn seed_to_campaign(seed: CompiledSeed, receipts: &[VaultEvidenceReceipt]) -> Re
revision: 0,
branch_origin: BranchOrigin {
canon_cutoff: seed.canon_cutoff,
evidence_receipt_ids: receipt_ids(receipts),
evidence_receipt_ids,
},
world_time: seed.world_time,
tick_hours: seed.tick_hours,
@ -351,6 +495,13 @@ fn seed_to_campaign(seed: CompiledSeed, receipts: &[VaultEvidenceReceipt]) -> Re
}],
last_player_activity: now,
pending_ticks: 0,
away_ticks_processed: 0,
events: vec![],
news: vec![],
canon_candidates,
gestalts: BTreeMap::new(),
gestalt_members: BTreeMap::new(),
pending_world_proposals: vec![],
})
}
@ -416,7 +567,7 @@ mod tests {
"locations":[{"id":"yard","name":"Yard","container_id":null,"routes":{"out":{"destination_id":destination,"distance":"near","travel_minutes":5}},"persistent_features":["same yard"]}],
"actors":[],"institutions":[],"clocks":[{"id":"shift","label":"Shift ends","progress":0,"threshold":4,"consequence":"night"}],
"facts":[{"id":"f","statement":"A witnessed fact","scope":"canon_baseline","evidence_receipt_ids":["fixture"]}],
"gaps":[],"branch_assumptions":[],"opening_narration":"The yard persists."
"gaps":["Who owns the outer gate?"],"branch_assumptions":[],"opening_narration":"The yard persists."
}).to_string()
}
_ => return Err(anyhow!("unexpected stage")),
@ -482,6 +633,7 @@ mod tests {
assert!(preview.requires_approval);
assert_eq!(preview.campaign.revision, 0);
assert_eq!(preview.campaign.locations.len(), 1);
assert_eq!(preview.campaign.canon_candidates.len(), 1);
}
#[tokio::test]

View file

@ -22,6 +22,20 @@ pub struct Campaign {
pub transcript: Vec<NarrativeTurn>,
pub last_player_activity: DateTime<Utc>,
pub pending_ticks: u8,
#[serde(default)]
pub away_ticks_processed: u8,
#[serde(default)]
pub events: Vec<Event>,
#[serde(default)]
pub news: Vec<NewsIssue>,
#[serde(default)]
pub canon_candidates: BTreeMap<String, CanonCandidate>,
#[serde(default)]
pub gestalts: BTreeMap<String, GestaltPersonaState>,
#[serde(default)]
pub gestalt_members: BTreeMap<String, GestaltMemberDelta>,
#[serde(default)]
pub pending_world_proposals: Vec<WorldActionProposal>,
}
#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
@ -58,6 +72,76 @@ pub struct ActorState {
pub obligations: BTreeSet<String>,
pub relationships: BTreeMap<String, String>,
pub goals: Vec<String>,
#[serde(default)]
pub memories: Vec<String>,
}
#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
pub struct GestaltPersonaState {
pub schema: String,
pub id: String,
pub name: String,
pub version: u64,
pub home_location_id: String,
pub shared_capabilities: BTreeSet<String>,
pub shared_knowledge: BTreeSet<String>,
pub resources: BTreeSet<String>,
pub goals: Vec<String>,
pub pressures: Vec<String>,
}
#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
pub struct GestaltMemberDelta {
pub schema: String,
pub id: String,
pub gestalt_id: String,
pub version: u64,
pub name: String,
pub capability_additions: BTreeSet<String>,
pub capability_removals: BTreeSet<String>,
pub knowledge_additions: BTreeSet<String>,
pub knowledge_removals: BTreeSet<String>,
pub equipment: BTreeSet<String>,
pub conditions: BTreeSet<String>,
pub obligations: BTreeSet<String>,
pub relationships: BTreeMap<String, String>,
pub goals: Vec<String>,
pub memories: Vec<String>,
pub last_location_id: Option<String>,
pub materialized_actor_id: Option<String>,
}
#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Default)]
pub struct GestaltAggregateDelta {
pub knowledge_additions: BTreeSet<String>,
pub resource_additions: BTreeSet<String>,
pub pressures: Vec<String>,
}
#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Default)]
pub struct ActorStateDelta {
pub memories_add: Vec<String>,
pub conditions_add: BTreeSet<String>,
pub conditions_remove: BTreeSet<String>,
pub goals_add: Vec<String>,
pub relationship_updates: BTreeMap<String, String>,
}
#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
pub struct WorldActionProposal {
pub actor_id: String,
pub intent: String,
pub intended_effect: String,
pub priority: i16,
pub state_references: Vec<String>,
}
#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
pub struct ActorReaction {
pub actor_id: String,
pub speech: Option<String>,
pub private_delta: ActorStateDelta,
pub action_proposals: Vec<WorldActionProposal>,
}
#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
@ -86,6 +170,41 @@ pub struct WorldFact {
pub evidence_receipt_ids: Vec<String>,
}
#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
pub struct Event {
pub id: String,
pub at: DateTime<Utc>,
pub kind: String,
pub summary: String,
pub actor_ids: Vec<String>,
pub institution_ids: Vec<String>,
pub location_ids: Vec<String>,
pub public_channels: Vec<String>,
}
#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
pub struct NewsIssue {
pub id: String,
pub at: DateTime<Utc>,
pub channel: String,
pub headline: String,
pub event_ids: Vec<String>,
pub reliability: String,
}
#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
pub struct CanonCandidate {
pub schema: String,
pub id: String,
pub originating_campaign_id: Uuid,
pub gap: String,
pub evidence_receipt_ids: Vec<String>,
pub conflicts: Vec<String>,
pub proposed_wording: String,
pub affected_vault_sources: Vec<String>,
pub status: String,
}
#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum FactScope {
@ -125,6 +244,8 @@ pub enum WorldCommand {
Assess {
expected_revision: u64,
intent: ActionIntent,
#[serde(default)]
proposal: Option<ActionAssessment>,
},
Attempt {
assessment_digest: String,
@ -137,6 +258,49 @@ pub enum WorldCommand {
expected_revision: u64,
source: TickSource,
},
ExpandRegion {
expected_revision: u64,
expansion: RegionExpansion,
evidence_receipts: Vec<VaultEvidenceReceipt>,
canon_candidates: Vec<CanonCandidate>,
},
MaterializeGestaltMember {
expected_revision: u64,
gestalt_id: String,
expected_gestalt_version: u64,
member_id: String,
expected_member_version: u64,
location_id: String,
},
DematerializeGestaltMember {
expected_revision: u64,
actor_id: String,
aggregate_delta: GestaltAggregateDelta,
},
ResolveReactionWave {
expected_revision: u64,
event_summary: String,
reactions: Vec<ActorReaction>,
},
}
#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
pub struct RegionExpansion {
pub origin_location_id: String,
pub locations: Vec<Location>,
pub facts: Vec<WorldFact>,
}
#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
pub struct RegionExpansionPreview {
pub schema: String,
pub campaign_id: Uuid,
pub expected_revision: u64,
pub expansion: RegionExpansion,
pub evidence_receipts: Vec<VaultEvidenceReceipt>,
pub gaps: Vec<String>,
pub canon_candidates: Vec<CanonCandidate>,
pub requires_approval: bool,
}
#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]

View file

@ -4,7 +4,7 @@ use crate::persistence::CampaignStore;
use chrono::{Duration, Utc};
use rand::Rng;
use sha2::{Digest, Sha256};
use std::collections::BTreeMap;
use std::collections::{BTreeMap, BTreeSet};
use thiserror::Error;
use tokio::sync::{mpsc, oneshot};
@ -102,9 +102,27 @@ fn execute(
WorldCommand::Assess {
expected_revision,
intent,
proposal,
} => {
require_revision(&campaign, expected_revision)?;
let assessment = assess(&campaign, intent);
let assessment = match proposal {
Some(assessment) => {
if assessment.campaign_id != campaign.id
|| assessment.revision != campaign.revision
|| assessment.intent != intent
|| assessment.expires_at < Utc::now()
|| crate::assessor::assessment_digest(&assessment)
.map_err(|error| KernelError::Invalid(error.to_string()))?
!= assessment.digest
{
return Err(KernelError::Invalid(
"assessment proposal is stale or invalid".into(),
));
}
assessment
}
None => assess(&campaign, intent),
};
assessments.insert(assessment.digest.clone(), assessment.clone());
Ok(CommandResult::Assessed { assessment })
}
@ -134,6 +152,9 @@ fn execute(
OutcomeBand::Mixed => &assessment.mixed_stake,
OutcomeBand::Failure => &assessment.failure_stake,
};
campaign.last_player_activity = Utc::now();
campaign.away_ticks_processed = 0;
campaign.pending_ticks = 0;
campaign.transcript.push(NarrativeTurn {
revision: campaign.revision + 1,
at: Utc::now(),
@ -167,6 +188,8 @@ fn execute(
});
}
campaign.last_player_activity = Utc::now();
campaign.away_ticks_processed = 0;
campaign.pending_ticks = 0;
commit(store, row, campaign, "speak", None)
}
WorldCommand::Wait {
@ -176,6 +199,8 @@ fn execute(
require_revision(&campaign, expected_revision)?;
campaign.world_time += Duration::minutes(i64::from(minutes));
campaign.last_player_activity = Utc::now();
campaign.away_ticks_processed = 0;
campaign.pending_ticks = 0;
commit(store, row, campaign, "wait", None)
}
WorldCommand::AdvanceStrategicTick {
@ -187,13 +212,371 @@ fn execute(
for clock in campaign.clocks.values_mut() {
clock.progress = clock.progress.saturating_add(1).min(clock.threshold);
}
let tick_number = campaign.away_ticks_processed.saturating_add(1);
let mut tick_events = Vec::new();
for institution in campaign.institutions.values_mut() {
let summary = if let Some(goal) = institution.goals.first() {
format!("{} advances its interest: {}", institution.name, goal)
} else {
format!("{} consolidates its current position", institution.name)
};
institution.posture = format!("acting after strategic tick {tick_number}");
let event_id = format!("strategic:{}:{}", campaign.revision + 1, institution.id);
tick_events.push(crate::domain::Event {
id: event_id,
at: campaign.world_time,
kind: "institution_action".into(),
summary,
actor_ids: vec![],
institution_ids: vec![institution.id.clone()],
location_ids: vec![],
public_channels: vec![format!("institution:{}", institution.id)],
});
}
for gestalt in campaign.gestalts.values_mut() {
gestalt.version += 1;
let summary = if let Some(goal) = gestalt.goals.first() {
format!("{} collectively advances: {}", gestalt.name, goal)
} else {
format!("{} carries on its shared routine", gestalt.name)
};
tick_events.push(crate::domain::Event {
id: format!("strategic:{}:gestalt:{}", campaign.revision + 1, gestalt.id),
at: campaign.world_time,
kind: "gestalt_action".into(),
summary,
actor_ids: vec![],
institution_ids: vec![],
location_ids: vec![gestalt.home_location_id.clone()],
public_channels: vec![format!("gestalt:{}", gestalt.id)],
});
}
let player = campaign.actors.get(&campaign.player_actor_id);
for event in &tick_events {
let accessible = event.public_channels.iter().find(|channel| {
player.is_some_and(|actor| {
actor.knowledge.contains(*channel)
|| actor.equipment.contains("communications")
})
});
if let Some(channel) = accessible {
campaign.news.push(crate::domain::NewsIssue {
id: format!("news:{}", event.id),
at: campaign.world_time,
channel: channel.clone(),
headline: event.summary.clone(),
event_ids: vec![event.id.clone()],
reliability: "direct institutional channel".into(),
});
}
}
campaign.events.extend(tick_events);
campaign.away_ticks_processed = tick_number.min(8);
campaign.pending_ticks = campaign.pending_ticks.saturating_sub(1);
commit(store, row, campaign, "strategic_tick", None)
}
WorldCommand::ExpandRegion {
expected_revision,
expansion,
evidence_receipts,
canon_candidates,
} => {
require_revision(&campaign, expected_revision)?;
crate::compiler::validate_region_expansion(&campaign, &expansion)
.map_err(|error| KernelError::Invalid(error.to_string()))?;
for location in expansion.locations {
campaign.locations.insert(location.id.clone(), location);
}
for fact in expansion.facts {
campaign.facts.insert(fact.id.clone(), fact);
}
for candidate in &canon_candidates {
campaign
.canon_candidates
.insert(candidate.id.clone(), candidate.clone());
}
commit_with_records(
store,
row,
campaign,
"expand_region",
evidence_receipts,
canon_candidates,
)
}
WorldCommand::MaterializeGestaltMember {
expected_revision,
gestalt_id,
expected_gestalt_version,
member_id,
expected_member_version,
location_id,
} => {
require_revision(&campaign, expected_revision)?;
if !campaign.locations.contains_key(&location_id) {
return Err(KernelError::Invalid(
"materialization location is unknown".into(),
));
}
let gestalt = campaign
.gestalts
.get(&gestalt_id)
.ok_or_else(|| KernelError::Invalid("gestalt is unknown".into()))?
.clone();
if gestalt.version != expected_gestalt_version {
return Err(KernelError::Invalid("gestalt snapshot is stale".into()));
}
let member = campaign
.gestalt_members
.get_mut(&member_id)
.ok_or_else(|| KernelError::Invalid("gestalt member is unknown".into()))?;
if member.gestalt_id != gestalt_id || member.version != expected_member_version {
return Err(KernelError::Invalid(
"member snapshot is stale or belongs to another gestalt".into(),
));
}
if member.materialized_actor_id.is_some() {
return Err(KernelError::Invalid(
"gestalt member is already materialized".into(),
));
}
let actor_id = format!("member:{}", member.id);
if campaign.actors.contains_key(&actor_id) {
return Err(KernelError::Invalid(
"materialized actor id collides".into(),
));
}
let actor = materialize_actor(&gestalt, member, &actor_id, &location_id);
member.materialized_actor_id = Some(actor_id.clone());
member.last_location_id = Some(location_id);
member.version += 1;
campaign.actors.insert(actor_id, actor);
commit(store, row, campaign, "materialize_gestalt_member", None)
}
WorldCommand::DematerializeGestaltMember {
expected_revision,
actor_id,
aggregate_delta,
} => {
require_revision(&campaign, expected_revision)?;
let actor = campaign
.actors
.get(&actor_id)
.ok_or_else(|| KernelError::Invalid("materialized actor is unknown".into()))?
.clone();
let member_id = campaign
.gestalt_members
.values()
.find(|member| member.materialized_actor_id.as_deref() == Some(actor_id.as_str()))
.map(|member| member.id.clone())
.ok_or_else(|| {
KernelError::Invalid("actor is not a materialized gestalt member".into())
})?;
let gestalt_id = campaign.gestalt_members[&member_id].gestalt_id.clone();
let gestalt = campaign
.gestalts
.get_mut(&gestalt_id)
.ok_or_else(|| KernelError::Invalid("gestalt is missing".into()))?;
let member = campaign
.gestalt_members
.get_mut(&member_id)
.expect("member exists");
fold_actor_delta(&actor, gestalt, member);
member.materialized_actor_id = None;
member.version += 1;
if !aggregate_delta.knowledge_additions.is_empty()
|| !aggregate_delta.resource_additions.is_empty()
|| !aggregate_delta.pressures.is_empty()
{
gestalt
.shared_knowledge
.extend(aggregate_delta.knowledge_additions);
gestalt.resources.extend(aggregate_delta.resource_additions);
gestalt.pressures.extend(aggregate_delta.pressures);
gestalt.version += 1;
}
campaign.actors.remove(&actor_id);
commit(store, row, campaign, "dematerialize_gestalt_member", None)
}
WorldCommand::ResolveReactionWave {
expected_revision,
event_summary,
reactions,
} => {
require_revision(&campaign, expected_revision)?;
let player_location = campaign.actors[&campaign.player_actor_id]
.location_id
.clone();
let mut seen = BTreeSet::new();
for reaction in &reactions {
if !seen.insert(reaction.actor_id.clone()) {
return Err(KernelError::Invalid(
"actor reacted twice in one wave".into(),
));
}
let actor = campaign
.actors
.get(&reaction.actor_id)
.ok_or_else(|| KernelError::Invalid("reaction actor is unknown".into()))?;
if actor.location_id != player_location {
return Err(KernelError::Invalid("reaction actor is not present".into()));
}
for proposal in &reaction.action_proposals {
validate_world_proposal(actor, proposal)?;
}
}
for reaction in reactions {
let actor = campaign
.actors
.get_mut(&reaction.actor_id)
.expect("validated actor");
actor.memories.extend(reaction.private_delta.memories_add);
actor
.conditions
.extend(reaction.private_delta.conditions_add);
for value in reaction.private_delta.conditions_remove {
actor.conditions.remove(&value);
}
actor.goals.extend(reaction.private_delta.goals_add);
actor
.relationships
.extend(reaction.private_delta.relationship_updates);
if let Some(speech) = reaction.speech {
campaign.transcript.push(NarrativeTurn {
revision: campaign.revision + 1,
at: Utc::now(),
speaker: reaction.actor_id.clone(),
text: speech,
});
}
campaign
.pending_world_proposals
.extend(reaction.action_proposals);
}
campaign.events.push(Event {
id: format!("reaction-wave:{}", campaign.revision + 1),
at: campaign.world_time,
kind: "reaction_wave".into(),
summary: event_summary,
actor_ids: seen.into_iter().collect(),
institution_ids: vec![],
location_ids: vec![player_location],
public_channels: vec![],
});
commit(store, row, campaign, "reaction_wave", None)
}
WorldCommand::CreateCampaign { .. } => unreachable!(),
}
}
fn validate_world_proposal(
actor: &ActorState,
proposal: &WorldActionProposal,
) -> Result<(), KernelError> {
if proposal.actor_id != actor.id
|| proposal.intent.trim().is_empty()
|| proposal.intended_effect.trim().is_empty()
{
return Err(KernelError::Invalid(
"world action proposal is malformed".into(),
));
}
let allowed: BTreeSet<String> = actor
.capabilities
.iter()
.map(|x| format!("capability:{x}"))
.chain(actor.knowledge.iter().map(|x| format!("knowledge:{x}")))
.chain(actor.equipment.iter().map(|x| format!("equipment:{x}")))
.chain(std::iter::once(format!("location:{}", actor.location_id)))
.collect();
if proposal
.state_references
.iter()
.any(|reference| !allowed.contains(reference))
{
return Err(KernelError::Invalid(
"world action proposal cites unearned state".into(),
));
}
Ok(())
}
fn overlay(
base: &BTreeSet<String>,
add: &BTreeSet<String>,
remove: &BTreeSet<String>,
) -> BTreeSet<String> {
base.difference(remove)
.cloned()
.chain(add.iter().cloned())
.collect()
}
fn materialize_actor(
gestalt: &GestaltPersonaState,
member: &GestaltMemberDelta,
actor_id: &str,
location_id: &str,
) -> ActorState {
ActorState {
id: actor_id.into(),
name: member.name.clone(),
location_id: location_id.into(),
capabilities: overlay(
&gestalt.shared_capabilities,
&member.capability_additions,
&member.capability_removals,
),
knowledge: overlay(
&gestalt.shared_knowledge,
&member.knowledge_additions,
&member.knowledge_removals,
),
equipment: member.equipment.clone(),
conditions: member.conditions.clone(),
obligations: member.obligations.clone(),
relationships: member.relationships.clone(),
goals: if member.goals.is_empty() {
gestalt.goals.clone()
} else {
member.goals.clone()
},
memories: member.memories.clone(),
}
}
fn fold_actor_delta(
actor: &ActorState,
gestalt: &GestaltPersonaState,
member: &mut GestaltMemberDelta,
) {
member.capability_additions = actor
.capabilities
.difference(&gestalt.shared_capabilities)
.cloned()
.collect();
member.capability_removals = gestalt
.shared_capabilities
.difference(&actor.capabilities)
.cloned()
.collect();
member.knowledge_additions = actor
.knowledge
.difference(&gestalt.shared_knowledge)
.cloned()
.collect();
member.knowledge_removals = gestalt
.shared_knowledge
.difference(&actor.knowledge)
.cloned()
.collect();
member.equipment = actor.equipment.clone();
member.conditions = actor.conditions.clone();
member.obligations = actor.obligations.clone();
member.relationships = actor.relationships.clone();
member.goals = actor.goals.clone();
member.memories = actor.memories.clone();
member.last_location_id = Some(actor.location_id.clone());
}
fn single_campaign_id(store: &CampaignStore) -> Result<String, KernelError> {
let keys = store.keys("campaign.v1").map_err(persist)?;
match keys.as_slice() {
@ -291,6 +674,38 @@ fn commit(
Ok(CommandResult::Committed { campaign, receipt })
}
fn commit_with_records(
store: &CampaignStore,
row: cultcache_rs::CultCacheEnvelope,
mut campaign: Campaign,
kind: &str,
evidence: Vec<VaultEvidenceReceipt>,
candidates: Vec<CanonCandidate>,
) -> Result<CommandResult, KernelError> {
let previous_revision = campaign.revision;
campaign.revision += 1;
let receipt = WorldCommitReceipt {
schema: "ghostlight.world_commit_receipt.v1".into(),
campaign_id: campaign.id,
previous_revision,
revision: campaign.revision,
command_kind: kind.into(),
committed_at: Utc::now(),
roll: None,
};
store
.append_world_commit(
&row,
&campaign,
&format!("{}-{}", campaign.id, campaign.revision),
&receipt,
&evidence,
&candidates,
)
.map_err(persist)?;
Ok(CommandResult::Committed { campaign, receipt })
}
fn persist(e: anyhow::Error) -> KernelError {
KernelError::Persistence(e.to_string())
}
@ -313,6 +728,7 @@ mod tests {
obligations: BTreeSet::new(),
relationships: BTreeMap::new(),
goals: vec![],
memories: vec![],
};
Campaign {
schema: "ghostlight.campaign.v1".into(),
@ -343,6 +759,13 @@ mod tests {
transcript: vec![],
last_player_activity: Utc::now(),
pending_ticks: 0,
away_ticks_processed: 0,
events: vec![],
news: vec![],
canon_candidates: BTreeMap::new(),
gestalts: BTreeMap::new(),
gestalt_members: BTreeMap::new(),
pending_world_proposals: vec![],
}
}
@ -402,6 +825,7 @@ mod tests {
description: "Open the ordinary door".into(),
intended_effect: "Pass through".into(),
},
proposal: None,
})
.await
.unwrap();
@ -426,4 +850,309 @@ mod tests {
assert!(receipt.roll.is_some());
assert_eq!(store.keys("world_commit_receipt.v1").unwrap().len(), 1);
}
#[tokio::test]
async fn strategic_tick_moves_institutions_but_news_respects_access() {
let dir = tempfile::tempdir().unwrap();
let store = CampaignStore::open(dir.path().join("campaign.cc")).unwrap();
let kernel = WorldKernel::start(store.clone());
let mut seed = campaign();
seed.institutions.insert(
"board".into(),
InstitutionState {
id: "board".into(),
name: "Board".into(),
resources: vec!["permits".into()],
goals: vec!["contain the strike".into()],
posture: "watching".into(),
},
);
kernel
.command(WorldCommand::CreateCampaign {
campaign: seed.clone(),
evidence_receipts: vec![],
})
.await
.unwrap();
let result = kernel
.command(WorldCommand::AdvanceStrategicTick {
expected_revision: 0,
source: TickSource::Scheduler,
})
.await
.unwrap();
let CommandResult::Committed { campaign, .. } = result else {
panic!("expected commit")
};
assert_eq!(campaign.events.len(), 1);
assert!(campaign.news.is_empty());
assert_eq!(campaign.away_ticks_processed, 1);
assert!(campaign.institutions["board"].posture.contains("acting"));
}
#[tokio::test]
async fn region_expansion_commits_topology_evidence_and_candidate_together() {
let dir = tempfile::tempdir().unwrap();
let store = CampaignStore::open(dir.path().join("campaign.cc")).unwrap();
let kernel = WorldKernel::start(store.clone());
let seed = campaign();
kernel
.command(WorldCommand::CreateCampaign {
campaign: seed.clone(),
evidence_receipts: vec![],
})
.await
.unwrap();
let evidence = VaultEvidenceReceipt {
schema: "ghostlight.vault_evidence_receipt.v1".into(),
id: "vault:route".into(),
provider: "fixture".into(),
query_hash: "sha256:q".into(),
witnesses: vec![],
retrieved_at: Utc::now(),
};
let candidate = CanonCandidate {
schema: "ghostlight.canon_candidate.v1".into(),
id: "candidate:gate".into(),
originating_campaign_id: seed.id,
gap: "Who owns the gate?".into(),
evidence_receipt_ids: vec![evidence.id.clone()],
conflicts: vec![],
proposed_wording: "Clarify gate ownership".into(),
affected_vault_sources: vec![],
status: "review".into(),
};
let location = Location {
id: "annex".into(),
name: "Annex".into(),
container_id: None,
routes: BTreeMap::from([(
"back".into(),
Route {
destination_id: "room".into(),
distance: "near".into(),
travel_minutes: 10,
},
)]),
persistent_features: vec!["stable annex".into()],
};
let result = kernel
.command(WorldCommand::ExpandRegion {
expected_revision: 0,
expansion: RegionExpansion {
origin_location_id: "room".into(),
locations: vec![location],
facts: vec![],
},
evidence_receipts: vec![evidence],
canon_candidates: vec![candidate],
})
.await
.unwrap();
let CommandResult::Committed { campaign, .. } = result else {
panic!("expected commit")
};
assert!(campaign.locations.contains_key("annex"));
assert_eq!(campaign.revision, 1);
assert_eq!(store.keys("vault_evidence_receipt.v1").unwrap().len(), 1);
assert_eq!(store.keys("canon_candidate.v1").unwrap().len(), 1);
}
#[tokio::test]
async fn gestalt_member_dematerializes_to_delta_and_returns_as_same_person() {
let dir = tempfile::tempdir().unwrap();
let store = CampaignStore::open(dir.path().join("campaign.cc")).unwrap();
let kernel = WorldKernel::start(store);
let mut seed = campaign();
seed.gestalts.insert(
"village".into(),
GestaltPersonaState {
schema: "ghostlight.gestalt_persona_state.v1".into(),
id: "village".into(),
name: "The villagers".into(),
version: 0,
home_location_id: "room".into(),
shared_capabilities: BTreeSet::from(["basic smithing".into()]),
shared_knowledge: BTreeSet::from(["village roads".into()]),
resources: BTreeSet::new(),
goals: vec!["keep the village fed".into()],
pressures: vec![],
},
);
seed.gestalt_members.insert(
"john".into(),
GestaltMemberDelta {
schema: "ghostlight.gestalt_member_delta.v1".into(),
id: "john".into(),
gestalt_id: "village".into(),
version: 0,
name: "John".into(),
capability_additions: BTreeSet::from(["master blacksmith".into()]),
capability_removals: BTreeSet::new(),
knowledge_additions: BTreeSet::new(),
knowledge_removals: BTreeSet::new(),
equipment: BTreeSet::from(["John's hammer".into()]),
conditions: BTreeSet::new(),
obligations: BTreeSet::new(),
relationships: BTreeMap::from([("player".into(), "new acquaintance".into())]),
goals: vec![],
memories: vec!["met the player".into()],
last_location_id: None,
materialized_actor_id: None,
},
);
kernel
.command(WorldCommand::CreateCampaign {
campaign: seed,
evidence_receipts: vec![],
})
.await
.unwrap();
let first = kernel
.command(WorldCommand::MaterializeGestaltMember {
expected_revision: 0,
gestalt_id: "village".into(),
expected_gestalt_version: 0,
member_id: "john".into(),
expected_member_version: 0,
location_id: "room".into(),
})
.await
.unwrap();
let CommandResult::Committed {
campaign: first, ..
} = first
else {
panic!()
};
assert!(
first.actors["member:john"]
.capabilities
.contains("master blacksmith")
);
let folded = kernel
.command(WorldCommand::DematerializeGestaltMember {
expected_revision: 1,
actor_id: "member:john".into(),
aggregate_delta: GestaltAggregateDelta {
knowledge_additions: BTreeSet::from(["the player keeps promises".into()]),
..Default::default()
},
})
.await
.unwrap();
let CommandResult::Committed {
campaign: folded, ..
} = folded
else {
panic!()
};
assert!(!folded.actors.contains_key("member:john"));
assert_eq!(
folded.gestalt_members["john"].memories,
vec!["met the player"]
);
let again = kernel
.command(WorldCommand::MaterializeGestaltMember {
expected_revision: 2,
gestalt_id: "village".into(),
expected_gestalt_version: 1,
member_id: "john".into(),
expected_member_version: 2,
location_id: "room".into(),
})
.await
.unwrap();
let CommandResult::Committed {
campaign: again, ..
} = again
else {
panic!()
};
assert_eq!(again.actors["member:john"].name, "John");
assert_eq!(
again.actors["member:john"].relationships["player"],
"new acquaintance"
);
assert!(
again.gestalts["village"]
.shared_knowledge
.contains("the player keeps promises")
);
}
#[tokio::test]
async fn invalid_reaction_rejects_the_entire_wave_without_mutation() {
let dir = tempfile::tempdir().unwrap();
let store = CampaignStore::open(dir.path().join("campaign.cc")).unwrap();
let kernel = WorldKernel::start(store.clone());
let mut seed = campaign();
for id in ["anna", "bert"] {
seed.actors.insert(
id.into(),
ActorState {
id: id.into(),
name: id.into(),
location_id: "room".into(),
capabilities: BTreeSet::from(["observe".into()]),
knowledge: BTreeSet::new(),
equipment: BTreeSet::new(),
conditions: BTreeSet::new(),
obligations: BTreeSet::new(),
relationships: BTreeMap::new(),
goals: vec![],
memories: vec![],
},
);
}
kernel
.command(WorldCommand::CreateCampaign {
campaign: seed.clone(),
evidence_receipts: vec![],
})
.await
.unwrap();
let reactions = vec![
ActorReaction {
actor_id: "anna".into(),
speech: Some("I saw that.".into()),
private_delta: ActorStateDelta {
memories_add: vec!["saw the event".into()],
..Default::default()
},
action_proposals: vec![],
},
ActorReaction {
actor_id: "bert".into(),
speech: None,
private_delta: ActorStateDelta::default(),
action_proposals: vec![WorldActionProposal {
actor_id: "bert".into(),
intent: "invoke secret lore".into(),
intended_effect: "control the room".into(),
priority: 10,
state_references: vec!["knowledge:unearned secret lore".into()],
}],
},
];
assert!(
kernel
.command(WorldCommand::ResolveReactionWave {
expected_revision: 0,
event_summary: "the player acts".into(),
reactions,
})
.await
.is_err()
);
let persisted = store
.load::<Campaign>("campaign.v1", &seed.id.to_string())
.unwrap()
.unwrap()
.1;
assert_eq!(persisted.revision, 0);
assert!(persisted.actors["anna"].memories.is_empty());
assert!(persisted.transcript.is_empty());
assert!(persisted.pending_world_proposals.is_empty());
}
}

View file

@ -1,3 +1,4 @@
pub mod assessor;
pub mod compiler;
pub mod d20;
pub mod domain;
@ -5,7 +6,9 @@ pub mod kernel;
pub mod model;
pub mod persistence;
pub mod persona;
pub mod scheduler;
pub mod surface;
pub mod turn;
pub mod vault;
#[cfg(windows)]
pub mod windows_secret;

View file

@ -9,11 +9,14 @@ use axum::{
use ghostlight_dungeon::windows_secret::unprotect_machine_utf8;
use ghostlight_dungeon::{
WorldKernel,
assessor::ActionAssessor,
compiler::{CustomStart, OpeningRequest, OpeningSuggestion, SelectedStart, WorldCompiler},
domain::{Campaign, WorldCommand, WorldCompilePreview},
domain::{Campaign, RegionExpansionPreview, WorldCommand, WorldCompilePreview},
model::{DeepSeekPort, ModelPort, ModelStageRequest, run_validated_stage},
persistence::CampaignStore,
persona::PersonaProjectionEngine,
surface::player_surface,
turn::{SnapshotPermit, appraise_present},
vault::VoidBotMcpVault,
};
use serde::Deserialize;
@ -36,7 +39,10 @@ struct AppState {
auth: Arc<Mutex<AuthOwner>>,
deepseek_status: String,
compiler: Option<Arc<WorldCompiler>>,
assessor: Option<Arc<ActionAssessor>>,
model: Option<Arc<dyn ModelPort>>,
compile_previews: Arc<Mutex<BTreeMap<String, WorldCompilePreview>>>,
expansion_previews: Arc<Mutex<BTreeMap<String, RegionExpansionPreview>>>,
}
#[derive(Clone, Serialize, Deserialize)]
@ -111,7 +117,7 @@ async fn main() -> anyhow::Result<()> {
}
};
let secret_path = runtime_root.join("secrets/deepseek.dpapi");
let (deepseek_status, compiler) = if secret_path.is_file() {
let (deepseek_status, compiler, assessor, shared_model) = if secret_path.is_file() {
let provider: Arc<dyn ModelPort> =
Arc::new(DeepSeekPort::from_machine_dpapi(&secret_path)?);
let probe = run_validated_stage(
@ -130,12 +136,17 @@ async fn main() -> anyhow::Result<()> {
format!("ready:{}", probe.receipt.output_hash),
Some(Arc::new(WorldCompiler::new(
Arc::new(VoidBotMcpVault::starfire_loopback()),
provider,
provider.clone(),
"deepseek-v4-pro",
))),
Some(Arc::new(ActionAssessor::new(
provider.clone(),
"deepseek-v4-pro",
))),
Some(provider),
)
} else {
("missing-secret".into(), None)
("missing-secret".into(), None, None, None)
};
let state = AppState {
kernel,
@ -147,8 +158,12 @@ async fn main() -> anyhow::Result<()> {
})),
deepseek_status,
compiler,
assessor,
model: shared_model,
compile_previews: Arc::new(Mutex::new(BTreeMap::new())),
expansion_previews: Arc::new(Mutex::new(BTreeMap::new())),
};
tokio::spawn(scheduler_loop(state.clone()));
let release_web_root = std::env::current_exe()?
.parent()
.map(|parent| parent.join("web"));
@ -164,6 +179,11 @@ async fn main() -> anyhow::Result<()> {
.route("/api/compiler/selected", post(compile_selected))
.route("/api/compiler/custom", post(compile_custom))
.route("/api/compiler/approve/{preview_id}", post(approve_preview))
.route("/api/compiler/destination", post(compile_destination))
.route(
"/api/compiler/destination/approve/{preview_id}",
post(approve_destination),
)
.route("/api/command", post(command))
.fallback_service(ServeDir::new(web_root).append_index_html_on_directories(true))
.with_state(state);
@ -373,16 +393,197 @@ async fn approve_preview(
}
}
async fn command(
#[derive(Deserialize)]
struct DestinationRequest {
origin_location_id: String,
destination: String,
}
async fn compile_destination(
headers: HeaderMap,
State(state): State<AppState>,
Json(command): Json<WorldCommand>,
Json(request): Json<DestinationRequest>,
) -> Response {
if !authorized(&headers, &state).await {
return StatusCode::UNAUTHORIZED.into_response();
}
let campaign = match load_campaign(&state.store) {
Ok(value) => value,
Err(error) => return (StatusCode::NOT_FOUND, error.to_string()).into_response(),
};
let Some(compiler) = &state.compiler else {
return (
StatusCode::SERVICE_UNAVAILABLE,
"DeepSeek credential is unavailable",
)
.into_response();
};
match compiler
.compile_destination(&campaign, &request.origin_location_id, &request.destination)
.await
{
Ok((preview, receipt)) => {
let id = uuid::Uuid::new_v4().to_string();
state
.expansion_previews
.lock()
.await
.insert(id.clone(), preview.clone());
Json(serde_json::json!({"preview_id":id,"preview":preview,"model_receipt":receipt}))
.into_response()
}
Err(error) => (StatusCode::UNPROCESSABLE_ENTITY, error.to_string()).into_response(),
}
}
async fn approve_destination(
Path(preview_id): Path<String>,
headers: HeaderMap,
State(state): State<AppState>,
) -> Response {
if !authorized(&headers, &state).await {
return StatusCode::UNAUTHORIZED.into_response();
}
let Some(preview) = state.expansion_previews.lock().await.remove(&preview_id) else {
return (StatusCode::NOT_FOUND, "preview missing or already consumed").into_response();
};
match state
.kernel
.command(WorldCommand::ExpandRegion {
expected_revision: preview.expected_revision,
expansion: preview.expansion,
evidence_receipts: preview.evidence_receipts,
canon_candidates: preview.canon_candidates,
})
.await
{
Ok(value) => Json(value).into_response(),
Err(error) => (StatusCode::CONFLICT, error.to_string()).into_response(),
}
}
async fn command(
headers: HeaderMap,
State(state): State<AppState>,
Json(mut command): Json<WorldCommand>,
) -> Response {
if !authorized(&headers, &state).await {
return StatusCode::UNAUTHORIZED.into_response();
}
if let Err(error) = process_due_ticks(&state).await {
return (
StatusCode::CONFLICT,
Json(ErrorBody {
error: error.to_string(),
}),
)
.into_response();
}
if let WorldCommand::Assess {
intent, proposal, ..
} = &mut command
{
if proposal.is_none() {
let Some(assessor) = &state.assessor else {
return (
StatusCode::SERVICE_UNAVAILABLE,
Json(ErrorBody {
error: "DeepSeek assessor is unavailable".into(),
}),
)
.into_response();
};
let campaign = match load_campaign(&state.store) {
Ok(value) => value,
Err(error) => {
return (
StatusCode::NOT_FOUND,
Json(ErrorBody {
error: error.to_string(),
}),
)
.into_response();
}
};
match assessor.assess(&campaign, intent.clone()).await {
Ok((assessment, receipt)) => {
let _ = state.store.insert(
"persona_stage_receipt.v1",
"ghostlight.persona_stage_receipt.v1",
&receipt.output_hash,
&receipt,
);
*proposal = Some(assessment);
}
Err(error) => {
return (
StatusCode::UNPROCESSABLE_ENTITY,
Json(ErrorBody {
error: error.to_string(),
}),
)
.into_response();
}
}
}
}
let should_react = matches!(
&command,
WorldCommand::Attempt { .. } | WorldCommand::Speak { .. }
);
match state.kernel.command(command).await {
Ok(result) => Json(result).into_response(),
Ok(result) => {
if should_react {
if let ghostlight_dungeon::kernel::CommandResult::Committed { campaign, .. } =
&result
{
if campaign.actors.len() > 1 {
if let Some(model) = &state.model {
let summary = campaign
.transcript
.last()
.map(|turn| turn.text.clone())
.unwrap_or_else(|| "A consequential event occurred.".into());
let engine = PersonaProjectionEngine {
model: model.clone(),
permit: Arc::new(SnapshotPermit::new(
state.store.clone(),
campaign.id,
campaign.revision,
)),
projector_model: "deepseek-v4-flash".into(),
persona_model: "deepseek-v4-pro".into(),
interpreter_model: "deepseek-v4-flash".into(),
};
match appraise_present(engine, campaign, &summary).await {
Ok(wave) if !wave.reactions.is_empty() => {
for receipt in wave.receipts {
let _ = state.store.insert(
"persona_stage_receipt.v1",
"ghostlight.persona_stage_receipt.v1",
&receipt.output_hash,
&receipt,
);
}
match state.kernel.command(WorldCommand::ResolveReactionWave{expected_revision:campaign.revision,event_summary:summary,reactions:wave.reactions}).await{Ok(reaction)=>return Json(serde_json::json!({"primary":result,"reaction_wave":reaction})).into_response(),Err(error)=>return(StatusCode::CONFLICT,Json(ErrorBody{error:error.to_string()})).into_response()}
}
Ok(_) => {}
Err(error) => {
return (
StatusCode::BAD_GATEWAY,
Json(ErrorBody {
error: error.to_string(),
}),
)
.into_response();
}
}
}
}
}
}
Json(result).into_response()
}
Err(error) => (
StatusCode::CONFLICT,
Json(ErrorBody {
@ -393,6 +594,41 @@ async fn command(
}
}
async fn scheduler_loop(state: AppState) {
let mut pulse = tokio::time::interval(std::time::Duration::from_secs(300));
pulse.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
pulse.tick().await;
loop {
pulse.tick().await;
if let Err(error) = process_due_ticks(&state).await {
tracing::warn!(%error,"strategic scheduler pulse refused");
}
}
}
async fn process_due_ticks(state: &AppState) -> anyhow::Result<()> {
loop {
let campaign = match load_campaign(&state.store) {
Ok(value) => value,
Err(_) => return Ok(()),
};
let target = ghostlight_dungeon::scheduler::due_tick_target(
chrono::Utc::now(),
campaign.last_player_activity,
);
if campaign.away_ticks_processed >= target {
return Ok(());
}
state
.kernel
.command(WorldCommand::AdvanceStrategicTick {
expected_revision: campaign.revision,
source: ghostlight_dungeon::domain::TickSource::ReturnCatchUp,
})
.await?;
}
}
async fn authorized(headers: &HeaderMap, state: &AppState) -> bool {
let session = headers
.get(header::COOKIE)
@ -459,6 +695,7 @@ fn seed_campaign() -> Campaign {
obligations: BTreeSet::new(),
relationships: BTreeMap::new(),
goals: vec!["Compile a world worth entering.".into()],
memories: vec![],
};
Campaign {
schema: "ghostlight.campaign.v1".into(),
@ -480,5 +717,12 @@ fn seed_campaign() -> Campaign {
transcript: vec![],
last_player_activity: chrono::Utc::now(),
pending_ticks: 0,
away_ticks_processed: 0,
events: vec![],
news: vec![],
canon_candidates: BTreeMap::new(),
gestalts: BTreeMap::new(),
gestalt_members: BTreeMap::new(),
pending_world_proposals: vec![],
}
}

View file

@ -90,7 +90,7 @@ pub struct FixtureModel;
impl ModelPort for FixtureModel {
async fn run(&self, request: &ModelStageRequest) -> Result<String> {
Ok(if request.output_schema.is_some() {
r#"{"private_deltas":[],"speech":null,"reaction_priority":0,"world_actions":[]}"#.into()
r#"{"private_delta":{"memories_add":[],"conditions_add":[],"conditions_remove":[],"goals_add":[],"relationship_updates":{}},"speech":null,"reaction_priority":0,"world_actions":[]}"#.into()
} else {
format!("{}", request.lived_stream)
})

View file

@ -81,6 +81,14 @@ impl CampaignStore {
receipt,
)?);
}
for candidate in campaign.canon_candidates.values() {
rows.push(envelope(
"canon_candidate.v1",
"ghostlight.canon_candidate.v1",
&candidate.id,
candidate,
)?);
}
if !self.inner.compare_and_swap_batch(&[], rows)? {
return Err(anyhow!("campaign store is not empty"));
}
@ -120,6 +128,55 @@ impl CampaignStore {
}
Ok(next_row)
}
pub fn append_world_commit<T: Serialize, R: Serialize>(
&self,
expected: &CultCacheEnvelope,
next: &T,
receipt_key: &str,
receipt: &R,
evidence: &[VaultEvidenceReceipt],
candidates: &[crate::domain::CanonCandidate],
) -> Result<CultCacheEnvelope> {
let next_row = envelope(
&expected.r#type,
"ghostlight.campaign.v1",
&expected.key,
next,
)?;
let mut rows = vec![
next_row.clone(),
envelope(
"world_commit_receipt.v1",
"ghostlight.world_commit_receipt.v1",
receipt_key,
receipt,
)?,
];
for item in evidence {
rows.push(envelope(
"vault_evidence_receipt.v1",
"ghostlight.vault_evidence_receipt.v1",
&item.id,
item,
)?);
}
for item in candidates {
rows.push(envelope(
"canon_candidate.v1",
"ghostlight.canon_candidate.v1",
&item.id,
item,
)?);
}
if !self
.inner
.compare_and_swap_batch(std::slice::from_ref(expected), rows)?
{
return Err(anyhow!("stale CultCache snapshot"));
}
Ok(next_row)
}
}
fn envelope<T: Serialize>(

View file

@ -1,6 +1,7 @@
use crate::model::{ModelPort, ModelStageRequest, run_validated_stage};
use anyhow::{Result, anyhow};
use async_trait::async_trait;
use schemars::{JsonSchema, schema_for};
use serde::{Deserialize, Serialize};
use std::sync::Arc;
@ -27,12 +28,12 @@ pub struct LivedNarrativeStream {
pub projector_receipt: crate::model::ModelStageReceipt,
}
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
pub struct PersonaProposalBundle {
pub private_deltas: Vec<serde_json::Value>,
pub private_delta: crate::domain::ActorStateDelta,
pub speech: Option<String>,
pub reaction_priority: i16,
pub world_actions: Vec<serde_json::Value>,
pub world_actions: Vec<crate::domain::WorldActionProposal>,
}
#[derive(Clone, Debug)]
@ -57,6 +58,7 @@ impl ExecutionPermit for AllowAllPermit {
}
}
#[derive(Clone)]
pub struct PersonaProjectionEngine {
pub model: Arc<dyn ModelPort>,
pub permit: Arc<dyn ExecutionPermit>,
@ -113,17 +115,14 @@ impl PersonaProjectionEngine {
self.permit
.require(&slice.actor_id, &slice.snapshot_binding, "interpreter")
.await?;
let schema = serde_json::json!({"type":"object","required":["private_deltas","speech","reaction_priority","world_actions"]});
let schema = serde_json::to_value(schema_for!(PersonaProposalBundle))?;
let interpreted = run_validated_stage(
self.model.as_ref(),
&ModelStageRequest {
stage: "interpreter".into(),
model: self.interpreter_model.clone(),
snapshot_binding: slice.snapshot_binding.clone(),
lived_stream: format!(
"LIVED STREAM:\n{}\n\nPERSONA OUTPUT:\n{}",
lived.text, persona.narrative
),
lived_stream: format!("Interpret the Persona output into the exact JSON schema below. Record only private changes supported by the lived stream. World actions are attempts, not completed effects. Every world action actor_id must be {}.\nSCHEMA:\n{}\nLIVED STREAM:\n{}\n\nPERSONA OUTPUT:\n{}",slice.actor_id,serde_json::to_string_pretty(&schema)?,lived.text, persona.narrative),
output_schema: Some(schema),
source_receipt_ids: slice.source_receipt_ids,
},

View file

@ -0,0 +1,24 @@
use chrono::{DateTime, Utc};
pub fn due_tick_target(now: DateTime<Utc>, last_player_activity: DateTime<Utc>) -> u8 {
let idle = now - last_player_activity;
if idle < chrono::Duration::minutes(15) {
0
} else {
(idle.num_hours().max(0) as u8).min(8)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn away_budget_waits_and_caps_at_eight() {
let now = Utc::now();
assert_eq!(due_tick_target(now, now - chrono::Duration::minutes(14)), 0);
assert_eq!(due_tick_target(now, now - chrono::Duration::minutes(59)), 0);
assert_eq!(due_tick_target(now, now - chrono::Duration::hours(1)), 1);
assert_eq!(due_tick_target(now, now - chrono::Duration::hours(30)), 8);
}
}

View file

@ -3,14 +3,53 @@ use serde_json::{Value, json};
pub fn player_surface(campaign: &Campaign) -> Value {
let turns = campaign.transcript.iter().map(|t| json!({"id":format!("turn-{}-{}",t.revision,t.speaker),"kind":"text","props":{"value":format!("{}: {}",t.speaker,t.text)},"children":[]})).collect::<Vec<_>>();
let player = &campaign.actors[&campaign.player_actor_id];
let location = &campaign.locations[&player.location_id];
let ledger = format!(
"Capabilities: {}\nEquipment: {}\nConditions: {}\nObligations: {}\nKnown facts: {}",
join(&player.capabilities),
join(&player.equipment),
join(&player.conditions),
join(&player.obligations),
join(&player.knowledge)
);
let pressures = campaign
.clocks
.values()
.map(|clock| {
format!(
"{} {}/{} — {}",
clock.label, clock.progress, clock.threshold, clock.consequence
)
})
.chain(
campaign
.institutions
.values()
.map(|x| format!("{} — {}", x.name, x.posture)),
)
.collect::<Vec<_>>()
.join("\n");
let news=campaign.news.iter().map(|item|json!({"id":item.id,"kind":"text","props":{"value":format!("[{}] {}",item.channel,item.headline)},"children":[]})).collect::<Vec<_>>();
json!({
"type":"surface-state", "schema":"gamecult.eve.surface.v1", "providerId":"gamecult.ghostlight.dungeon",
"providerKind":"narrative.simulation", "title":campaign.name, "version":campaign.revision,
"surface":{"id":format!("ghostlight.campaign.{}",campaign.id),"root":{"id":"dungeon.root","kind":"surface","props":{},"children":[
{"id":"dungeon.status","kind":"card","props":{"title":format!("{} · revision {} · {}",campaign.name,campaign.revision,campaign.world_time)},"children":[]},
{"id":"dungeon.location","kind":"card","props":{"title":format!("{} · {}",location.name,player.name)},"children":[{"id":"dungeon.pressures","kind":"text","props":{"value":pressures},"children":[]}]},
{"id":"dungeon.ledger","kind":"card","props":{"title":"Character ledger"},"children":[{"id":"dungeon.ledger.text","kind":"text","props":{"value":ledger},"children":[]}]},
{"id":"dungeon.news","kind":"card","props":{"title":"Accessible news and rumors"},"children":news},
{"id":"dungeon.transcript","kind":"card","props":{"title":"Story"},"children":turns},
{"id":"dungeon.composer","kind":"text-input","props":{"label":"What do you attempt?","commandId":"attempt.assess"},"children":[]}
]},"styles":{"tokens":{"colorBackground":"#0c1110","colorPanel":"#17201d","colorText":"#e8e1cf","colorMuted":"#9aa69f","colorAccent":"#d49b58"}}},
"commands":[{"id":"attempt.assess","schema":"gamecult.eve.command.v1","receiptSchema":"ghostlight.player_action_assessment.v1"}]
})
}
fn join(values: &std::collections::BTreeSet<String>) -> String {
if values.is_empty() {
"none".into()
} else {
values.iter().cloned().collect::<Vec<_>>().join(", ")
}
}

View file

@ -0,0 +1,112 @@
use crate::{
domain::{ActorReaction, Campaign},
model::ModelStageReceipt,
persistence::CampaignStore,
persona::{ExecutionPermit, PermittedActorSlice, PersonaProjectionEngine},
};
use anyhow::{Result, anyhow};
use async_trait::async_trait;
pub struct SnapshotPermit {
store: CampaignStore,
campaign_id: uuid::Uuid,
revision: u64,
}
impl SnapshotPermit {
pub fn new(store: CampaignStore, campaign_id: uuid::Uuid, revision: u64) -> Self {
Self {
store,
campaign_id,
revision,
}
}
}
#[async_trait]
impl ExecutionPermit for SnapshotPermit {
async fn require(&self, _: &str, _: &str, _: &str) -> Result<()> {
let value = self
.store
.load::<Campaign>("campaign.v1", &self.campaign_id.to_string())?
.map(|(_, c)| c)
.ok_or_else(|| anyhow!("campaign vanished during Persona wave"))?;
if value.revision != self.revision {
return Err(anyhow!("Persona projection snapshot is stale"));
}
Ok(())
}
}
pub struct ReactionWaveOutput {
pub reactions: Vec<ActorReaction>,
pub receipts: Vec<ModelStageReceipt>,
}
pub async fn appraise_present(
engine: PersonaProjectionEngine,
campaign: &Campaign,
event_summary: &str,
) -> Result<ReactionWaveOutput> {
let player = campaign
.actors
.get(&campaign.player_actor_id)
.ok_or_else(|| anyhow!("player actor missing"))?;
let actors: Vec<_> = campaign
.actors
.values()
.filter(|actor| {
actor.id != campaign.player_actor_id && actor.location_id == player.location_id
})
.cloned()
.collect();
let mut jobs = tokio::task::JoinSet::new();
for actor in actors {
let engine = engine.clone();
let snapshot = format!("campaign:{}:revision:{}", campaign.id, campaign.revision);
let event = event_summary.to_owned();
let receipts = campaign.branch_origin.evidence_receipt_ids.clone();
jobs.spawn(async move {
let slice = PermittedActorSlice {
actor_id: actor.id.clone(),
snapshot_binding: snapshot,
identity_experience: vec![format!("You are {}.", actor.name)],
memories: actor.memories,
perceived_events: vec![event],
relationships: actor
.relationships
.into_iter()
.map(|(id, value)| format!("{id}: {value}"))
.collect(),
goals: actor.goals,
knowledge: actor.knowledge.into_iter().collect(),
capabilities: actor.capabilities.into_iter().collect(),
pressures: actor
.conditions
.into_iter()
.chain(actor.obligations)
.collect(),
affordances: actor.equipment.into_iter().collect(),
source_receipt_ids: receipts,
};
let terminal = engine.execute(slice).await?;
Ok::<_, anyhow::Error>((actor.id, terminal))
});
}
let mut reactions = Vec::new();
let mut receipts = Vec::new();
while let Some(result) = jobs.join_next().await {
let (actor_id, terminal) =
result.map_err(|e| anyhow!("Persona appraisal task failed: {e}"))??;
receipts.extend(terminal.stage_receipts);
reactions.push(ActorReaction {
actor_id,
speech: terminal.proposals.speech,
private_delta: terminal.proposals.private_delta,
action_proposals: terminal.proposals.world_actions,
});
}
reactions.sort_by(|a, b| a.actor_id.cmp(&b.actor_id));
Ok(ReactionWaveOutput {
reactions,
receipts,
})
}

View file

@ -165,6 +165,39 @@ implementation to make competing decisions after migration.
## Persona projection ownership
### Gestalt population materialization
Large low-focus populations use a gestalt Persona without sacrificing durable
individual identity.
- **Owner:** `WorldKernel` owns whether a member currently occupies an active
actor slot. The gestalt owns shared baseline state. The member delta owns
individual divergence.
- **Inputs:** relevance/perception proposal, expected campaign revision,
expected gestalt version, expected member-delta version, current scene, and
reviewed consequences.
- **Outputs:** a materialized actor derived from baseline plus delta, or an
updated persistent delta plus optional reviewed aggregate gestalt changes and
a materialization receipt.
- **Derived state:** the active actor is a projection/composition. It is not a
second owner of the gestalt or member identity.
- **Forbidden writers:** proximity checks, Persona output, scheduler, scene
rendering, and relevance heuristics may propose promotion or demotion but
cannot create, erase, merge, or rewrite a person.
- **Shared paths:** first encounter, named interaction, return to a known
member, leaving perception, scene teardown, reload, and offscreen catch-up
all use `MaterializeGestaltMember` or `DematerializeGestaltMember` through the
campaign mailbox.
- **Cut line:** dematerialization never deletes the member delta. Gestalt ticks
never overwrite member-specific memories, relationships, possessions,
injuries, promises, or identity.
The composition order is `gestalt baseline -> persistent member delta ->
current scene`. Dematerialization writes individual consequences to the delta;
only explicitly reviewed population-level learning may update the gestalt.
This allows a corporation or village to take one strategic turn while John the
blacksmith remains John when encountered again.
### The ownership decision
Ghostlight owns the reusable Persona projection machinery:

View file

@ -50,6 +50,21 @@ Ghostlight’s existing v0 schemas and training fixtures remain evidence and reg
### Persona and world action loop
Population scaling uses reversible gestalt materialization. A crowd, village,
crew, or corporation may act offscreen through one gestalt Persona. When a
specific member becomes relevant, the WorldKernel materializes an individual
from the gestalt baseline plus a persistent member delta and current scene.
When relevance expires, it folds individual consequences back into that delta,
admits only reviewed aggregate learning to the gestalt, and removes the active
simulation slot. The member delta remains durable so returning to the person
reconstructs the same individual rather than a fresh approximation.
Gestalt projection, relevance detection, and merge proposals cannot commit.
`MaterializeGestaltMember` and `DematerializeGestaltMember` use the normal
revisioned WorldCommand path. A named member's relationships, memories,
possessions, injuries, promises, and identity never become disposable gestalt
texture.
Ghostlight owns its own generalized projection machinery:
1. Projector converts the actor’s permitted typed slice, memories, perceived events, relationships, goals, and retrieved knowledge into a private lived narrative stream.
@ -134,6 +149,8 @@ DeepSeek currently documents both V4 model IDs, streaming, and JSON output throu
- `player_action_assessment.v1`, `roll_receipt.v1`, `world_commit_receipt.v1`
- `persona_stage_receipt.v1`, `actor_state_delta.v1`, `world_action_proposal.v1`
- `strategic_tick.v1`, `news_issue.v1`, `canon_candidate.v1`
- `gestalt_persona_state.v1`, `gestalt_member_delta.v1`,
`gestalt_materialization_receipt.v1`
- Existing `gamecult.eve.surface.v1` and `gamecult.eve.command.v1`
Publish JSON Schema only as the schema catalog. Runtime documents and exports use MessagePack-backed CultCache `.cc`; JSON exists only at browser, MCP, and model-provider boundaries.

View file

@ -19,8 +19,8 @@ campaign-plus-evidence admission, and the browser opening/role/custom flow. A
live DeepSeek plus VoidBot custom compilation passed without committing. A
disposable HTTP run proved approval persistence and durable hashed invite and
session state across restart. Implement material-gap decisions, on-demand
destination compilation, and canon-candidate persistence before moving to the
action/Persona loop.
destination compilation, canon-candidate persistence, and reversible gestalt
member materialization before moving to the action/Persona loop.
## Prior research-program phase

View file

@ -254,5 +254,6 @@ data_flow:
- If state grows faster than understanding, cut it back.
current_status:
summary: GhostlightDungeon is the active MVP program. The world-compiler seam retrieves hashed VoidBot witnesses, generates distinct openings and roles, compiles approval-gated custom starts, rejects invalid typed topology, and admits campaign plus evidence through the WorldKernel only after approval. Its browser flow is built; live DeepSeek plus VoidBot compilation passed with 30 witnessed chunks; disposable HTTP acceptance proved approval, campaign, hashed session, and consumed-invite persistence across restart. The broader hosted MVP remains incomplete.
next_action: Implement material-gap decisions, on-demand destination compilation, and canon-candidate persistence before moving to the action and Persona loop.
summary: GhostlightDungeon is the active MVP program. The approval-gated world compiler now persists evidence, canon candidates, and bounded on-demand region expansion through the WorldKernel. Fiction-first assessments use model proposals with deterministic DC and state-reference validation. Away-time ticks move institutions and gate news by information access. Present NPCs appraise live events in parallel Persona waves, and the kernel atomically validates their private deltas and world-action proposals. Gestalt populations can materialize durable individuals and fold them back into persistent member deltas. Live DeepSeek plus VoidBot compilation and disposable authenticated HTTP restart smokes have passed. The broader hosted MVP remains incomplete.
next_action: Complete initiative selection and world resolution for validated NPC proposals, narrator projection, automatic relevance-driven gestalt presence planning, and the campaign/operator laboratory controls.
gestalt_population: Gestalt Personas own shared population baselines; persistent member deltas own named individuality; WorldKernel materialization commands compose and demote active actors without deleting member identity.

File diff suppressed because one or more lines are too long

3
web/dist/index.html vendored
View file

@ -1,5 +1,5 @@
<!doctype html>
<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>GhostlightDungeon</title> <script type="module" crossorigin src="/assets/index-Dqaht4pv.js"></script>
<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>GhostlightDungeon</title> <script type="module" crossorigin src="/assets/index-BkVLQG59.js"></script>
<link rel="stylesheet" crossorigin href="/assets/index-Dt7lvyL0.css">
</head>
<body><header><p class="eyebrow">STARFIRE / PRIVATE VERSE</p><h1>GhostlightDungeon</h1><p id="status">Reading the world…</p></header><main>
@ -8,4 +8,5 @@
<form id="custom-form"><label>Or describe your own beginning</label><input name="campaign_name" placeholder="Campaign name" required><input name="who" placeholder="Who are you?" required><input name="where_" placeholder="Where?" required><input name="when" placeholder="When?" required><textarea name="goal" placeholder="What do you want?" required></textarea><button type="submit">Compile custom start</button></form>
</div><div id="compiler-results"></div></section><section id="surface"></section>
<form id="composer"><label for="attempt">Describe what you attempt</label><textarea id="attempt" required></textarea><div><button type="submit">Assess</button><button type="button" id="wait">Wait one hour</button></div></form><pre id="receipt" hidden></pre>
<form id="destination-form"><label>Compile a destination without moving there</label><input name="origin_location_id" placeholder="Current location id" required><input name="destination" placeholder="Where do you want the world to extend?" required><button type="submit">Retrieve destination</button></form>
</main></body></html>

View file

@ -6,4 +6,5 @@
<form id="custom-form"><label>Or describe your own beginning</label><input name="campaign_name" placeholder="Campaign name" required><input name="who" placeholder="Who are you?" required><input name="where_" placeholder="Where?" required><input name="when" placeholder="When?" required><textarea name="goal" placeholder="What do you want?" required></textarea><button type="submit">Compile custom start</button></form>
</div><div id="compiler-results"></div></section><section id="surface"></section>
<form id="composer"><label for="attempt">Describe what you attempt</label><textarea id="attempt" required></textarea><div><button type="submit">Assess</button><button type="button" id="wait">Wait one hour</button></div></form><pre id="receipt" hidden></pre>
<form id="destination-form"><label>Compile a destination without moving there</label><input name="origin_location_id" placeholder="Current location id" required><input name="destination" placeholder="Where do you want the world to extend?" required><button type="submit">Retrieve destination</button></form>
</main><script type="module" src="/src/main.ts"></script></body></html>

View file

@ -7,6 +7,7 @@ const status = document.querySelector<HTMLElement>("#status")!;
const receipt = document.querySelector<HTMLElement>("#receipt")!;
const compiler = document.querySelector<HTMLElement>("#compiler")!;
const composer = document.querySelector<HTMLFormElement>("#composer")!;
const destinationForm = document.querySelector<HTMLFormElement>("#destination-form")!;
const compilerResults = document.querySelector<HTMLElement>("#compiler-results")!;
let revision = 0;
@ -15,7 +16,7 @@ async function refresh() {
if (response.status === 401) { status.textContent = "This laboratory requires an unused invite link."; return; }
const surface = await response.json();
const needsCompilation = surface.surface_id === "ghostlight.compiler";
compiler.hidden = !needsCompilation; composer.hidden = needsCompilation; host.hidden = needsCompilation;
compiler.hidden = !needsCompilation; composer.hidden = needsCompilation; destinationForm.hidden = needsCompilation; host.hidden = needsCompilation;
if (needsCompilation) { status.textContent = "No campaign exists. Retrieve the Vault and approve a world seed."; return; }
revision = Number(surface.version ?? 0);
renderEveSurface(surface, host, { body: document.body, clientId: "ghostlight.browser", statusElement: status });
@ -52,7 +53,8 @@ async function showPreview(result: any) {
status.textContent = "Preview compiled. Nothing has entered world state yet.";
}
async function send(command: unknown) { status.textContent = "The world is considering the command…"; const response = await fetch("/api/command", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(command) }); const body = await response.json(); receipt.hidden = false; receipt.textContent = JSON.stringify(body, null, 2); if (!response.ok) { status.textContent = body.error ?? "The command was refused."; return; } await refresh(); }
composer.addEventListener("submit", event => { event.preventDefault(); const text = document.querySelector<HTMLTextAreaElement>("#attempt")!.value.trim(); if (text) void send({ type: "assess", expected_revision: revision, intent: { actor_id: "player", description: text, intended_effect: text } }); });
async function send(command: unknown) { status.textContent = "The world is considering the command…"; const response = await fetch("/api/command", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(command) }); const body = await response.json(); receipt.hidden = false; receipt.textContent = JSON.stringify(body, null, 2); if (!response.ok) { status.textContent = body.error ?? "The command was refused."; await refresh(); return body; } await refresh(); return body; }
composer.addEventListener("submit", async event => { event.preventDefault(); const text = document.querySelector<HTMLTextAreaElement>("#attempt")!.value.trim(); if (!text) return; const result=await send({ type: "assess", expected_revision: revision, intent: { actor_id: "player", description: text, intended_effect: text } }); if(result?.kind==="assessed"){const button=document.createElement("button");button.textContent=result.assessment.admissible?"Confirm server roll":"Revise attempt";button.addEventListener("click",async()=>{if(result.assessment.admissible){await send({type:"attempt",assessment_digest:result.assessment.digest});button.remove();}else{document.querySelector<HTMLTextAreaElement>("#attempt")!.focus();}});composer.append(button);} });
document.querySelector<HTMLButtonElement>("#wait")!.addEventListener("click", () => void send({ type: "wait", expected_revision: revision, minutes: 60 }));
destinationForm.addEventListener("submit",async event=>{event.preventDefault();const result=await compilerPost("/api/compiler/destination",Object.fromEntries(new FormData(destinationForm)));const preview=result.preview;receipt.hidden=false;receipt.textContent=JSON.stringify(preview,null,2);status.textContent="Destination preview compiled; topology is unchanged until approval.";const button=document.createElement("button");button.textContent="Approve destination";button.addEventListener("click",async()=>{await compilerPost(`/api/compiler/destination/approve/${result.preview_id}`,{});button.remove();await refresh();});destinationForm.append(button);});
void refresh();