10219 lines
400 KiB
Rust
10219 lines
400 KiB
Rust
use crate::d20::{capped_modifier, receipt};
|
|
use crate::domain::*;
|
|
use crate::persistence::CampaignStore;
|
|
use crate::session_zero::{
|
|
CampaignMembership, CellBudgetProposal, GroupTravelProposal, TimeAdvanceProposal,
|
|
};
|
|
use chrono::{Duration, Utc};
|
|
use rand::Rng;
|
|
use sha2::{Digest, Sha256};
|
|
use std::collections::{BTreeMap, BTreeSet};
|
|
use thiserror::Error;
|
|
use tokio::sync::{mpsc, oneshot};
|
|
|
|
const GESTALT_RELEVANCE_LEASE_REVISIONS: u64 = 2;
|
|
|
|
#[derive(Debug, Error)]
|
|
pub enum KernelError {
|
|
#[error("campaign not found")]
|
|
NotFound,
|
|
#[error("stale revision: expected {expected}, actual {actual}")]
|
|
Stale { expected: u64, actual: u64 },
|
|
#[error("action is impossible: {0}")]
|
|
Impossible(String),
|
|
#[error("assessment is unknown")]
|
|
UnknownAssessment,
|
|
#[error("assessment is stale at campaign revision {actual_revision}")]
|
|
StaleAssessment {
|
|
intent: ActionIntent,
|
|
actual_revision: u64,
|
|
},
|
|
#[error("invalid command: {0}")]
|
|
Invalid(String),
|
|
#[error("persistence failure: {0}")]
|
|
Persistence(String),
|
|
}
|
|
|
|
#[derive(Clone, Debug, serde::Serialize)]
|
|
#[serde(tag = "kind", rename_all = "snake_case")]
|
|
pub enum CommandResult {
|
|
Created {
|
|
campaign: Campaign,
|
|
},
|
|
Assessed {
|
|
assessment: ActionAssessment,
|
|
},
|
|
Committed {
|
|
campaign: Campaign,
|
|
receipt: WorldCommitReceipt,
|
|
},
|
|
ExternalSnapshotCommitted {
|
|
campaign: Campaign,
|
|
receipt: crate::consumer::ExternalSnapshotReceipt,
|
|
},
|
|
ResolutionUpdated {
|
|
campaign: Campaign,
|
|
receipt: ResolutionControlReceipt,
|
|
},
|
|
GovernancePending {
|
|
campaign: Campaign,
|
|
proposal: TimeAdvanceProposal,
|
|
},
|
|
TravelGovernancePending {
|
|
campaign: Campaign,
|
|
proposal: GroupTravelProposal,
|
|
},
|
|
ResolutionGovernancePending {
|
|
campaign: Campaign,
|
|
proposal: CellBudgetProposal,
|
|
},
|
|
MutationCommitted {
|
|
state: crate::transition::ComponentWorldState,
|
|
receipt: crate::transition::WorldMutationReceipt,
|
|
},
|
|
}
|
|
|
|
enum KernelInput {
|
|
World(WorldCommand),
|
|
Mutation {
|
|
authority: crate::transition::MutationAuthorityEnvelope,
|
|
batch: crate::transition::WorldMutationBatch,
|
|
},
|
|
}
|
|
|
|
struct Request {
|
|
input: KernelInput,
|
|
reply: oneshot::Sender<Result<CommandResult, KernelError>>,
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct WorldKernel {
|
|
tx: mpsc::Sender<Request>,
|
|
}
|
|
|
|
impl WorldKernel {
|
|
pub(crate) fn initialize_campaign(
|
|
store: &CampaignStore,
|
|
command: WorldCommand,
|
|
) -> Result<CommandResult, KernelError> {
|
|
if !matches!(command, WorldCommand::CreateCampaign { .. }) {
|
|
return Err(KernelError::Invalid(
|
|
"campaign initialization accepts only CreateCampaign".into(),
|
|
));
|
|
}
|
|
execute(store, &mut BTreeMap::new(), command)
|
|
}
|
|
|
|
pub fn start(store: CampaignStore) -> Self {
|
|
let (tx, mut rx) = mpsc::channel::<Request>(64);
|
|
tokio::spawn(async move {
|
|
let mut assessments = BTreeMap::new();
|
|
while let Some(request) = rx.recv().await {
|
|
let result = match request.input {
|
|
KernelInput::World(command) => execute(&store, &mut assessments, command),
|
|
KernelInput::Mutation { authority, batch } => {
|
|
execute_mutation_batch(&store, authority, batch)
|
|
}
|
|
};
|
|
let _ = request.reply.send(result);
|
|
}
|
|
});
|
|
Self { tx }
|
|
}
|
|
pub async fn command(&self, command: WorldCommand) -> Result<CommandResult, KernelError> {
|
|
let (reply, receive) = oneshot::channel();
|
|
self.tx
|
|
.send(Request {
|
|
input: KernelInput::World(command),
|
|
reply,
|
|
})
|
|
.await
|
|
.map_err(|_| KernelError::Invalid("kernel stopped".into()))?;
|
|
receive
|
|
.await
|
|
.map_err(|_| KernelError::Invalid("kernel stopped".into()))?
|
|
}
|
|
|
|
pub async fn commit_mutation_batch(
|
|
&self,
|
|
authority: crate::transition::MutationAuthorityEnvelope,
|
|
batch: crate::transition::WorldMutationBatch,
|
|
) -> Result<CommandResult, KernelError> {
|
|
let (reply, receive) = oneshot::channel();
|
|
self.tx
|
|
.send(Request {
|
|
input: KernelInput::Mutation { authority, batch },
|
|
reply,
|
|
})
|
|
.await
|
|
.map_err(|_| KernelError::Invalid("kernel stopped".into()))?;
|
|
receive
|
|
.await
|
|
.map_err(|_| KernelError::Invalid("kernel stopped".into()))?
|
|
}
|
|
}
|
|
|
|
fn execute_mutation_batch(
|
|
store: &CampaignStore,
|
|
authority: crate::transition::MutationAuthorityEnvelope,
|
|
batch: crate::transition::WorldMutationBatch,
|
|
) -> Result<CommandResult, KernelError> {
|
|
let key = batch.campaign_id.to_string();
|
|
if store
|
|
.load::<Campaign>("campaign.v1", &key)
|
|
.map_err(persist)?
|
|
.is_some()
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"aggregate campaigns accept mutations only through their WorldCommand mailbox".into(),
|
|
));
|
|
}
|
|
let (row, state) = store
|
|
.load::<crate::transition::ComponentWorldState>("component_world_state.v1", &key)
|
|
.map_err(persist)?
|
|
.ok_or(KernelError::NotFound)?;
|
|
let application =
|
|
crate::transition::apply_component_world_batch(&state, &authority, &batch, Utc::now())
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
store
|
|
.commit_world_mutation_batch(
|
|
&row,
|
|
&application.state,
|
|
&authority,
|
|
&batch,
|
|
&application.receipt,
|
|
)
|
|
.map_err(persist)?;
|
|
Ok(CommandResult::MutationCommitted {
|
|
state: application.state,
|
|
receipt: application.receipt,
|
|
})
|
|
}
|
|
|
|
fn execute(
|
|
store: &CampaignStore,
|
|
assessments: &mut BTreeMap<String, ActionAssessment>,
|
|
command: WorldCommand,
|
|
) -> Result<CommandResult, KernelError> {
|
|
if let WorldCommand::CreateCampaign {
|
|
mut campaign,
|
|
evidence_receipts,
|
|
model_stage_receipts,
|
|
} = command
|
|
{
|
|
if !store.keys("campaign.v1").map_err(persist)?.is_empty() {
|
|
return Err(KernelError::Invalid("campaign already exists".into()));
|
|
}
|
|
crate::resolution::ensure_agency_profiles(&mut campaign);
|
|
crate::compiler::validate_campaign_seed(&campaign)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
store
|
|
.create_unadmitted_fixture_campaign(
|
|
&campaign,
|
|
&evidence_receipts,
|
|
&model_stage_receipts,
|
|
)
|
|
.map_err(persist)?;
|
|
return Ok(CommandResult::Created { campaign });
|
|
}
|
|
let campaign_id = single_campaign_id(store)?;
|
|
let (row, mut campaign): (_, Campaign) = store
|
|
.load("campaign.v1", &campaign_id)
|
|
.map_err(persist)?
|
|
.ok_or(KernelError::NotFound)?;
|
|
match command {
|
|
WorldCommand::ApplyExternalSubjectSnapshot { snapshot } => {
|
|
if snapshot.schema != "ghostlight.external_subject_snapshot.v1"
|
|
|| snapshot.campaign_id != campaign.id
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"external snapshot targets another campaign".into(),
|
|
));
|
|
}
|
|
let receipt_key = format!("{}:{}", snapshot.authority_id, snapshot.source_revision);
|
|
if let Some((_, receipt)) = store
|
|
.load::<crate::consumer::ExternalSnapshotReceipt>(
|
|
"external_snapshot_receipt.v1",
|
|
&receipt_key,
|
|
)
|
|
.map_err(persist)?
|
|
{
|
|
return if receipt.payload_digest == snapshot.payload_digest
|
|
&& receipt.owner_id == snapshot.owner_id
|
|
{
|
|
Ok(CommandResult::ExternalSnapshotCommitted { campaign, receipt })
|
|
} else {
|
|
Err(KernelError::Invalid(
|
|
"external snapshot idempotency conflict".into(),
|
|
))
|
|
};
|
|
}
|
|
let (authority_row, authority) = store
|
|
.load::<crate::consumer::ExternalSubjectAuthority>(
|
|
"external_subject_authority.v1",
|
|
&snapshot.authority_id,
|
|
)
|
|
.map_err(persist)?
|
|
.ok_or_else(|| {
|
|
KernelError::Invalid("external subject authority is unknown".into())
|
|
})?;
|
|
if authority.campaign_id != snapshot.campaign_id
|
|
|| authority.owner_id != snapshot.owner_id
|
|
|| authority.subject_id != snapshot.projection.subject_id()
|
|
|| authority.subject_kind != snapshot.projection.subject_kind()
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"external snapshot does not match its authority".into(),
|
|
));
|
|
}
|
|
crate::consumer::validate_authority_key(&authority, &snapshot.authority_key)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
let actual_digest = crate::consumer::snapshot_payload_digest(&snapshot)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
if actual_digest != snapshot.payload_digest {
|
|
return Err(KernelError::Invalid(
|
|
"external snapshot payload digest is invalid".into(),
|
|
));
|
|
}
|
|
if authority
|
|
.last_source_revision
|
|
.is_some_and(|revision| snapshot.source_revision <= revision)
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"external snapshot source revision is stale".into(),
|
|
));
|
|
}
|
|
require_revision(&campaign, snapshot.expected_world_revision)?;
|
|
let subject_id = snapshot.projection.subject_id().to_owned();
|
|
let mut institution_ids = Vec::new();
|
|
let mut gestalt_ids = Vec::new();
|
|
match &snapshot.projection {
|
|
crate::consumer::ExternalSubjectProjection::Institution(value) => {
|
|
campaign
|
|
.institutions
|
|
.insert(value.id.clone(), value.clone());
|
|
institution_ids.push(value.id.clone());
|
|
if let Some(profile) = campaign.agency_profiles.get_mut(&value.id) {
|
|
profile.facets.insert(
|
|
AgencyAxis::Authority,
|
|
BTreeSet::from([value.id.clone(), value.posture.clone()]),
|
|
);
|
|
profile.facets.insert(
|
|
AgencyAxis::EconomyRole,
|
|
value.resources.iter().cloned().collect(),
|
|
);
|
|
}
|
|
}
|
|
crate::consumer::ExternalSubjectProjection::Gestalt(value) => {
|
|
campaign.gestalts.insert(value.id.clone(), value.clone());
|
|
gestalt_ids.push(value.id.clone());
|
|
if let Some(profile) = campaign.agency_profiles.get_mut(&value.id) {
|
|
profile.location_ids = BTreeSet::from([value.home_location_id.clone()]);
|
|
profile.facets.insert(
|
|
AgencyAxis::Geography,
|
|
BTreeSet::from([value.home_location_id.clone()]),
|
|
);
|
|
profile.facets.insert(
|
|
AgencyAxis::EconomyRole,
|
|
value.shared_capabilities.iter().cloned().collect(),
|
|
);
|
|
profile.facets.insert(
|
|
AgencyAxis::Information,
|
|
value.shared_knowledge.iter().cloned().collect(),
|
|
);
|
|
}
|
|
}
|
|
}
|
|
crate::compiler::validate_campaign_runtime(&campaign)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
let previous_world_revision = campaign.revision;
|
|
campaign.revision = campaign.revision.saturating_add(1);
|
|
let now = Utc::now();
|
|
campaign.events.push(Event {
|
|
id: format!(
|
|
"external-snapshot:{}:{}",
|
|
snapshot.authority_id, snapshot.source_revision
|
|
),
|
|
at: now,
|
|
kind: "external_subject_snapshot".into(),
|
|
summary: format!(
|
|
"{} supplied an authoritative external subject snapshot.",
|
|
snapshot.owner_id
|
|
),
|
|
actor_ids: Vec::new(),
|
|
institution_ids,
|
|
gestalt_ids,
|
|
location_ids: Vec::new(),
|
|
public_channels: Vec::new(),
|
|
});
|
|
let mut next_authority = authority;
|
|
next_authority.last_source_revision = Some(snapshot.source_revision);
|
|
next_authority.last_payload_digest = Some(snapshot.payload_digest.clone());
|
|
let receipt = crate::consumer::ExternalSnapshotReceipt {
|
|
schema: "ghostlight.external_snapshot_receipt.v1".into(),
|
|
id: receipt_key,
|
|
campaign_id: snapshot.campaign_id,
|
|
authority_id: snapshot.authority_id,
|
|
subject_id,
|
|
owner_id: snapshot.owner_id,
|
|
source_revision: snapshot.source_revision,
|
|
payload_digest: snapshot.payload_digest,
|
|
previous_world_revision,
|
|
world_revision: campaign.revision,
|
|
committed_at: now,
|
|
};
|
|
store
|
|
.append_external_snapshot(
|
|
&row,
|
|
&authority_row,
|
|
&campaign,
|
|
&next_authority,
|
|
&receipt,
|
|
)
|
|
.map_err(persist)?;
|
|
Ok(CommandResult::ExternalSnapshotCommitted { campaign, receipt })
|
|
}
|
|
WorldCommand::Assess {
|
|
expected_revision,
|
|
intent,
|
|
proposal,
|
|
} => {
|
|
require_revision(&campaign, expected_revision)?;
|
|
validate_intent_text(&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(),
|
|
));
|
|
}
|
|
let actor = campaign
|
|
.actors
|
|
.get(&assessment.intent.actor_id)
|
|
.ok_or_else(|| KernelError::Invalid("assessment actor vanished".into()))?;
|
|
for (effect, stake) in [
|
|
(&assessment.strong_effect, &assessment.success_stake),
|
|
(&assessment.success_effect, &assessment.success_stake),
|
|
(&assessment.mixed_effect, &assessment.mixed_stake),
|
|
(&assessment.failure_effect, &assessment.failure_stake),
|
|
] {
|
|
crate::assessor::validate_effect(&campaign, actor, effect, stake)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
validate_bounded_coop_effect(
|
|
store,
|
|
&campaign,
|
|
&assessment.intent.actor_id,
|
|
effect,
|
|
)?;
|
|
}
|
|
assessment
|
|
}
|
|
None => assess(&campaign, intent),
|
|
};
|
|
assessments.insert(assessment.digest.clone(), assessment.clone());
|
|
Ok(CommandResult::Assessed { assessment })
|
|
}
|
|
WorldCommand::Attempt {
|
|
actor_id,
|
|
assessment_digest,
|
|
} => {
|
|
let assessment = assessments
|
|
.get(&assessment_digest)
|
|
.cloned()
|
|
.ok_or(KernelError::UnknownAssessment)?;
|
|
if assessment.intent.actor_id != actor_id {
|
|
return Err(KernelError::Invalid(
|
|
"assessment belongs to another actor".into(),
|
|
));
|
|
}
|
|
if assessment.revision != campaign.revision || assessment.expires_at < Utc::now() {
|
|
assessments.remove(&assessment_digest);
|
|
return Err(KernelError::StaleAssessment {
|
|
intent: assessment.intent,
|
|
actual_revision: campaign.revision,
|
|
});
|
|
}
|
|
assessments.remove(&assessment_digest);
|
|
if !assessment.admissible {
|
|
return Err(KernelError::Impossible(
|
|
assessment
|
|
.missing_permission
|
|
.unwrap_or_else(|| "not admissible".into()),
|
|
));
|
|
}
|
|
let roll = receipt(
|
|
assessment.digest.clone(),
|
|
rand::rng().random_range(1..=20),
|
|
assessment.modifier_total,
|
|
assessment.dc,
|
|
);
|
|
let text = match roll.outcome {
|
|
OutcomeBand::StrongSuccess => &assessment.success_stake,
|
|
OutcomeBand::Success => &assessment.success_stake,
|
|
OutcomeBand::Mixed => &assessment.mixed_stake,
|
|
OutcomeBand::Failure => &assessment.failure_stake,
|
|
};
|
|
let effect = match roll.outcome {
|
|
OutcomeBand::StrongSuccess => assessment.strong_effect.clone(),
|
|
OutcomeBand::Success => assessment.success_effect.clone(),
|
|
OutcomeBand::Mixed => assessment.mixed_effect.clone(),
|
|
OutcomeBand::Failure => assessment.failure_effect.clone(),
|
|
};
|
|
let transition = crate::legacy_transition::lower_foreground_effect(
|
|
&campaign,
|
|
&assessment.intent.actor_id,
|
|
&effect,
|
|
roll.outcome.clone(),
|
|
crate::transition::MutationProcedure::ForegroundAttempt,
|
|
&assessment.effect_ceiling,
|
|
&assessment.digest,
|
|
Some(
|
|
crate::legacy_transition::digest_serializable(&assessment.intent)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?,
|
|
),
|
|
Some(
|
|
crate::legacy_transition::digest_serializable(
|
|
&assessment.intent.intended_effect,
|
|
)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?,
|
|
),
|
|
assessment.expires_at,
|
|
)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
let mutation_receipt = crate::legacy_transition::apply_lowered_transition(
|
|
&mut campaign,
|
|
&transition,
|
|
Utc::now(),
|
|
)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
refresh_materialized_member_relevance(
|
|
&mut campaign,
|
|
std::iter::once(assessment.intent.actor_id.as_str()),
|
|
);
|
|
if is_human_controlled_actor(&campaign, &assessment.intent.actor_id) {
|
|
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(),
|
|
speaker: "world".into(),
|
|
text: text.clone(),
|
|
persona_response_actor_ids: BTreeSet::new(),
|
|
});
|
|
commit_mutation_transition(
|
|
store,
|
|
row,
|
|
campaign,
|
|
"attempt",
|
|
Some(roll),
|
|
transition,
|
|
mutation_receipt,
|
|
)
|
|
}
|
|
WorldCommand::Speak {
|
|
expected_revision,
|
|
actor_id,
|
|
text,
|
|
intended_effect,
|
|
persona_response_actor_ids,
|
|
} => {
|
|
require_revision(&campaign, expected_revision)?;
|
|
validate_bounded_text("speech", &text, 4_000)?;
|
|
if let Some(effect) = &intended_effect {
|
|
validate_bounded_text("intended effect", effect, 1_000)?;
|
|
}
|
|
let speaker = campaign
|
|
.actors
|
|
.get(&actor_id)
|
|
.ok_or_else(|| KernelError::Invalid("unknown actor".into()))?;
|
|
for response_actor_id in &persona_response_actor_ids {
|
|
let eligible_present =
|
|
campaign.actors.get(response_actor_id).is_some_and(|actor| {
|
|
actor.location_id == speaker.location_id
|
|
&& campaign
|
|
.agency_profiles
|
|
.get(response_actor_id)
|
|
.is_none_or(|profile| profile.simulation_eligible)
|
|
});
|
|
let eligible_folded =
|
|
crate::resolution::dormant_member_id_for_subject(&campaign, response_actor_id)
|
|
.and_then(|member_id| {
|
|
crate::resolution::dormant_member_location(&campaign, member_id).ok()
|
|
})
|
|
.is_some_and(|location| location == speaker.location_id);
|
|
let eligible_gestalt = campaign.gestalts.get(response_actor_id).is_some_and(|_| {
|
|
crate::resolution::validate_active_gestalt_presence_location(
|
|
&campaign,
|
|
response_actor_id,
|
|
&speaker.location_id,
|
|
)
|
|
.is_ok()
|
|
});
|
|
if response_actor_id == &actor_id
|
|
|| !(eligible_present || eligible_folded || eligible_gestalt)
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"speech response actor is not an eligible present Persona".into(),
|
|
));
|
|
}
|
|
}
|
|
let response_actor_ids = persona_response_actor_ids.clone();
|
|
campaign.transcript.push(NarrativeTurn {
|
|
revision: campaign.revision + 1,
|
|
at: Utc::now(),
|
|
speaker: actor_id.clone(),
|
|
text,
|
|
persona_response_actor_ids,
|
|
});
|
|
if let Some(effect) = intended_effect {
|
|
campaign.transcript.push(NarrativeTurn {
|
|
revision: campaign.revision + 1,
|
|
at: Utc::now(),
|
|
speaker: "system".into(),
|
|
text: format!("Intended effect requires assessment: {effect}"),
|
|
persona_response_actor_ids: BTreeSet::new(),
|
|
});
|
|
}
|
|
refresh_materialized_member_relevance(
|
|
&mut campaign,
|
|
std::iter::once(actor_id.as_str())
|
|
.chain(response_actor_ids.iter().map(String::as_str)),
|
|
);
|
|
if is_human_controlled_actor(&campaign, &actor_id) {
|
|
campaign.last_player_activity = Utc::now();
|
|
campaign.away_ticks_processed = 0;
|
|
campaign.pending_ticks = 0;
|
|
}
|
|
commit(store, row, campaign, "speak", None)
|
|
}
|
|
WorldCommand::Wait {
|
|
expected_revision,
|
|
minutes,
|
|
} => {
|
|
require_revision(&campaign, expected_revision)?;
|
|
if minutes == 0 || minutes > 1_440 {
|
|
return Err(KernelError::Invalid(
|
|
"wait duration must be between 1 and 1440 minutes".into(),
|
|
));
|
|
}
|
|
let source_receipt_id = format!(
|
|
"direct-wait:{}:{}:{}",
|
|
campaign.id, campaign.revision, minutes
|
|
);
|
|
let transition = crate::legacy_transition::lower_time_advance(
|
|
&campaign,
|
|
minutes,
|
|
crate::transition::MutationProcedure::DirectCommand,
|
|
&source_receipt_id,
|
|
Utc::now() + Duration::minutes(5),
|
|
)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
let mutation_receipt = crate::legacy_transition::apply_lowered_transition(
|
|
&mut campaign,
|
|
&transition,
|
|
Utc::now(),
|
|
)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
campaign.last_player_activity = Utc::now();
|
|
campaign.away_ticks_processed = 0;
|
|
campaign.pending_ticks = 0;
|
|
commit_mutation_transition(
|
|
store,
|
|
row,
|
|
campaign,
|
|
"wait",
|
|
None,
|
|
transition,
|
|
mutation_receipt,
|
|
)
|
|
}
|
|
WorldCommand::ProposeTimeAdvance {
|
|
expected_revision,
|
|
member_id,
|
|
minutes,
|
|
} => {
|
|
require_revision(&campaign, expected_revision)?;
|
|
if minutes == 0 || minutes > 1_440 {
|
|
return Err(KernelError::Invalid(
|
|
"time advance must be between 1 and 1440 minutes".into(),
|
|
));
|
|
}
|
|
let membership = load_campaign_membership(store, campaign.id)?;
|
|
require_active_member(&membership, &member_id)?;
|
|
if store
|
|
.load_all::<TimeAdvanceProposal>("time_advance_proposal.v1")
|
|
.map_err(persist)?
|
|
.into_iter()
|
|
.any(|proposal| {
|
|
!proposal.committed && proposal.expected_world_revision == campaign.revision
|
|
})
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"a time-advance proposal is already pending at this revision".into(),
|
|
));
|
|
}
|
|
let proposal_id = format!("time:{}", uuid::Uuid::new_v4().simple());
|
|
let proposal = TimeAdvanceProposal {
|
|
schema: "ghostlight.time_advance_proposal.v1".into(),
|
|
id: proposal_id.clone(),
|
|
campaign_id: campaign.id,
|
|
expected_world_revision: campaign.revision,
|
|
minutes,
|
|
proposer_member_id: member_id.clone(),
|
|
approvals: BTreeSet::from([member_id]),
|
|
committed: false,
|
|
};
|
|
let proposal_row = store
|
|
.insert(
|
|
"time_advance_proposal.v1",
|
|
"ghostlight.time_advance_proposal.v1",
|
|
&proposal_id,
|
|
&proposal,
|
|
)
|
|
.map_err(persist)?;
|
|
if active_member_ids(&membership) == proposal.approvals {
|
|
commit_governed_time_advance(store, row, campaign, proposal_row, proposal)
|
|
} else {
|
|
Ok(CommandResult::GovernancePending { campaign, proposal })
|
|
}
|
|
}
|
|
WorldCommand::ApproveTimeAdvance {
|
|
expected_revision,
|
|
proposal_id,
|
|
member_id,
|
|
} => {
|
|
require_revision(&campaign, expected_revision)?;
|
|
let membership = load_campaign_membership(store, campaign.id)?;
|
|
require_active_member(&membership, &member_id)?;
|
|
let (proposal_row, mut proposal) = store
|
|
.load::<TimeAdvanceProposal>("time_advance_proposal.v1", &proposal_id)
|
|
.map_err(persist)?
|
|
.ok_or_else(|| KernelError::Invalid("time proposal does not exist".into()))?;
|
|
if proposal.committed
|
|
|| proposal.campaign_id != campaign.id
|
|
|| proposal.expected_world_revision != campaign.revision
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"time proposal is committed, stale, or belongs to another campaign".into(),
|
|
));
|
|
}
|
|
let newly_approved = proposal.approvals.insert(member_id);
|
|
if active_member_ids(&membership) == proposal.approvals {
|
|
commit_governed_time_advance(store, row, campaign, proposal_row, proposal)
|
|
} else if !newly_approved {
|
|
Err(KernelError::Invalid(
|
|
"member already approved this time proposal".into(),
|
|
))
|
|
} else {
|
|
store
|
|
.replace(
|
|
&proposal_row,
|
|
"ghostlight.time_advance_proposal.v1",
|
|
&proposal,
|
|
)
|
|
.map_err(persist)?;
|
|
Ok(CommandResult::GovernancePending { campaign, proposal })
|
|
}
|
|
}
|
|
WorldCommand::ProposeGroupTravel {
|
|
expected_revision,
|
|
member_id,
|
|
destination_location_id,
|
|
} => {
|
|
require_revision(&campaign, expected_revision)?;
|
|
let membership = load_campaign_membership(store, campaign.id)?;
|
|
let member = require_active_member(&membership, &member_id)?;
|
|
let origin_location_id = campaign
|
|
.actors
|
|
.get(&member.actor_id)
|
|
.ok_or_else(|| KernelError::Invalid("member actor is missing".into()))?
|
|
.location_id
|
|
.clone();
|
|
if membership
|
|
.members
|
|
.values()
|
|
.filter(|item| item.active)
|
|
.any(|item| {
|
|
campaign
|
|
.actors
|
|
.get(&item.actor_id)
|
|
.is_none_or(|actor| actor.location_id != origin_location_id)
|
|
})
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"group travel requires every player to occupy the same scene".into(),
|
|
));
|
|
}
|
|
let route = campaign
|
|
.locations
|
|
.get(&origin_location_id)
|
|
.and_then(|location| {
|
|
location
|
|
.routes
|
|
.values()
|
|
.find(|route| route.destination_id == destination_location_id)
|
|
})
|
|
.ok_or_else(|| {
|
|
KernelError::Invalid("destination is not directly reachable".into())
|
|
})?;
|
|
if store
|
|
.load_all::<GroupTravelProposal>("group_travel_proposal.v1")
|
|
.map_err(persist)?
|
|
.into_iter()
|
|
.any(|proposal| {
|
|
!proposal.committed && proposal.expected_world_revision == campaign.revision
|
|
})
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"a group-travel proposal is already pending at this revision".into(),
|
|
));
|
|
}
|
|
let proposal_id = format!("travel:{}", uuid::Uuid::new_v4().simple());
|
|
let proposal = GroupTravelProposal {
|
|
schema: "ghostlight.group_travel_proposal.v1".into(),
|
|
id: proposal_id.clone(),
|
|
campaign_id: campaign.id,
|
|
expected_world_revision: campaign.revision,
|
|
origin_location_id,
|
|
destination_location_id,
|
|
travel_minutes: route.travel_minutes,
|
|
proposer_member_id: member_id.clone(),
|
|
approvals: BTreeSet::from([member_id]),
|
|
committed: false,
|
|
};
|
|
let proposal_row = store
|
|
.insert(
|
|
"group_travel_proposal.v1",
|
|
"ghostlight.group_travel_proposal.v1",
|
|
&proposal_id,
|
|
&proposal,
|
|
)
|
|
.map_err(persist)?;
|
|
if active_member_ids(&membership) == proposal.approvals {
|
|
commit_governed_group_travel(
|
|
store,
|
|
row,
|
|
campaign,
|
|
proposal_row,
|
|
proposal,
|
|
&membership,
|
|
)
|
|
} else {
|
|
Ok(CommandResult::TravelGovernancePending { campaign, proposal })
|
|
}
|
|
}
|
|
WorldCommand::ApproveGroupTravel {
|
|
expected_revision,
|
|
proposal_id,
|
|
member_id,
|
|
} => {
|
|
require_revision(&campaign, expected_revision)?;
|
|
let membership = load_campaign_membership(store, campaign.id)?;
|
|
require_active_member(&membership, &member_id)?;
|
|
let (proposal_row, mut proposal) = store
|
|
.load::<GroupTravelProposal>("group_travel_proposal.v1", &proposal_id)
|
|
.map_err(persist)?
|
|
.ok_or_else(|| {
|
|
KernelError::Invalid("group-travel proposal does not exist".into())
|
|
})?;
|
|
if proposal.committed
|
|
|| proposal.campaign_id != campaign.id
|
|
|| proposal.expected_world_revision != campaign.revision
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"group-travel proposal is committed, stale, or belongs elsewhere".into(),
|
|
));
|
|
}
|
|
let newly_approved = proposal.approvals.insert(member_id);
|
|
if active_member_ids(&membership) == proposal.approvals {
|
|
commit_governed_group_travel(
|
|
store,
|
|
row,
|
|
campaign,
|
|
proposal_row,
|
|
proposal,
|
|
&membership,
|
|
)
|
|
} else if !newly_approved {
|
|
Err(KernelError::Invalid(
|
|
"member already approved this group-travel proposal".into(),
|
|
))
|
|
} else {
|
|
store
|
|
.replace(
|
|
&proposal_row,
|
|
"ghostlight.group_travel_proposal.v1",
|
|
&proposal,
|
|
)
|
|
.map_err(persist)?;
|
|
Ok(CommandResult::TravelGovernancePending { campaign, proposal })
|
|
}
|
|
}
|
|
WorldCommand::SetResolutionBudget {
|
|
expected_revision,
|
|
expected_resolution_epoch,
|
|
active_cell_budget,
|
|
} => {
|
|
require_revision(&campaign, expected_revision)?;
|
|
require_resolution_epoch(&campaign, expected_resolution_epoch)?;
|
|
if campaign.resolution_policy.active_cell_budget == active_cell_budget {
|
|
return Err(KernelError::Invalid(
|
|
"resolution budget command does not change the active cell budget".into(),
|
|
));
|
|
}
|
|
let previous_epoch = campaign.resolution_policy.resolution_epoch;
|
|
campaign.resolution_policy.active_cell_budget = active_cell_budget;
|
|
campaign.resolution_policy.pending_active_cell_budget = None;
|
|
crate::resolution::validate_policy(&campaign.resolution_policy)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
campaign.resolution_policy.resolution_epoch = previous_epoch.saturating_add(1);
|
|
campaign.resolution_cover = None;
|
|
commit_resolution_control(
|
|
store,
|
|
row,
|
|
campaign,
|
|
previous_epoch,
|
|
"set_active_cell_budget",
|
|
)
|
|
}
|
|
WorldCommand::ProposeResolutionBudget {
|
|
expected_revision,
|
|
expected_resolution_epoch,
|
|
member_id,
|
|
active_cell_budget,
|
|
} => {
|
|
require_revision(&campaign, expected_revision)?;
|
|
require_resolution_epoch(&campaign, expected_resolution_epoch)?;
|
|
let membership = load_campaign_membership(store, campaign.id)?;
|
|
require_active_member(&membership, &member_id)?;
|
|
if active_cell_budget == 0
|
|
|| active_cell_budget > membership.pooled_cell_allowance()
|
|
|| active_cell_budget == campaign.resolution_policy.active_cell_budget
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"cell budget must change and remain within the pooled allowance".into(),
|
|
));
|
|
}
|
|
if store
|
|
.load_all::<CellBudgetProposal>("cell_budget_proposal.v1")
|
|
.map_err(persist)?
|
|
.into_iter()
|
|
.any(|proposal| {
|
|
!proposal.committed
|
|
&& proposal.expected_world_revision == campaign.revision
|
|
&& proposal.expected_resolution_epoch
|
|
== campaign.resolution_policy.resolution_epoch
|
|
})
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"a cell-budget proposal is already pending at this boundary".into(),
|
|
));
|
|
}
|
|
let proposal_id = format!("cell-budget:{}", uuid::Uuid::new_v4().simple());
|
|
let proposal = CellBudgetProposal {
|
|
schema: "ghostlight.cell_budget_proposal.v1".into(),
|
|
id: proposal_id.clone(),
|
|
campaign_id: campaign.id,
|
|
expected_world_revision: campaign.revision,
|
|
expected_resolution_epoch: campaign.resolution_policy.resolution_epoch,
|
|
active_cell_budget,
|
|
proposer_member_id: member_id.clone(),
|
|
approvals: BTreeSet::from([member_id]),
|
|
committed: false,
|
|
};
|
|
let proposal_row = store
|
|
.insert(
|
|
"cell_budget_proposal.v1",
|
|
"ghostlight.cell_budget_proposal.v1",
|
|
&proposal_id,
|
|
&proposal,
|
|
)
|
|
.map_err(persist)?;
|
|
if active_member_ids(&membership) == proposal.approvals {
|
|
commit_governed_cell_budget(store, row, campaign, proposal_row, proposal)
|
|
} else {
|
|
Ok(CommandResult::ResolutionGovernancePending { campaign, proposal })
|
|
}
|
|
}
|
|
WorldCommand::ApproveResolutionBudget {
|
|
expected_revision,
|
|
proposal_id,
|
|
member_id,
|
|
} => {
|
|
require_revision(&campaign, expected_revision)?;
|
|
let membership = load_campaign_membership(store, campaign.id)?;
|
|
require_active_member(&membership, &member_id)?;
|
|
let (proposal_row, mut proposal) = store
|
|
.load::<CellBudgetProposal>("cell_budget_proposal.v1", &proposal_id)
|
|
.map_err(persist)?
|
|
.ok_or_else(|| {
|
|
KernelError::Invalid("cell-budget proposal does not exist".into())
|
|
})?;
|
|
if proposal.committed
|
|
|| proposal.campaign_id != campaign.id
|
|
|| proposal.expected_world_revision != campaign.revision
|
|
|| proposal.expected_resolution_epoch != campaign.resolution_policy.resolution_epoch
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"cell-budget proposal is committed, stale, or belongs elsewhere".into(),
|
|
));
|
|
}
|
|
let newly_approved = proposal.approvals.insert(member_id);
|
|
if active_member_ids(&membership) == proposal.approvals {
|
|
commit_governed_cell_budget(store, row, campaign, proposal_row, proposal)
|
|
} else if !newly_approved {
|
|
Err(KernelError::Invalid(
|
|
"member already approved this cell-budget proposal".into(),
|
|
))
|
|
} else {
|
|
store
|
|
.replace(
|
|
&proposal_row,
|
|
"ghostlight.cell_budget_proposal.v1",
|
|
&proposal,
|
|
)
|
|
.map_err(persist)?;
|
|
Ok(CommandResult::ResolutionGovernancePending { campaign, proposal })
|
|
}
|
|
}
|
|
WorldCommand::SetProviderParallelism {
|
|
expected_revision,
|
|
expected_provider_configuration_epoch,
|
|
provider_parallelism,
|
|
} => {
|
|
require_revision(&campaign, expected_revision)?;
|
|
if campaign.resolution_policy.provider_configuration_epoch
|
|
!= expected_provider_configuration_epoch
|
|
{
|
|
return Err(KernelError::Stale {
|
|
expected: expected_provider_configuration_epoch,
|
|
actual: campaign.resolution_policy.provider_configuration_epoch,
|
|
});
|
|
}
|
|
if campaign.resolution_policy.provider_parallelism == provider_parallelism {
|
|
return Err(KernelError::Invalid(
|
|
"provider parallelism command does not change provider configuration".into(),
|
|
));
|
|
}
|
|
campaign.resolution_policy.provider_parallelism = provider_parallelism;
|
|
crate::resolution::validate_policy(&campaign.resolution_policy)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
let previous_epoch = campaign.resolution_policy.resolution_epoch;
|
|
campaign.resolution_policy.provider_configuration_epoch = campaign
|
|
.resolution_policy
|
|
.provider_configuration_epoch
|
|
.saturating_add(1);
|
|
commit_resolution_control(
|
|
store,
|
|
row,
|
|
campaign,
|
|
previous_epoch,
|
|
"set_provider_parallelism",
|
|
)
|
|
}
|
|
WorldCommand::ReplaceResolutionPins {
|
|
expected_revision,
|
|
expected_resolution_epoch,
|
|
pins,
|
|
} => {
|
|
require_revision(&campaign, expected_revision)?;
|
|
require_resolution_epoch(&campaign, expected_resolution_epoch)?;
|
|
let mut replacement = BTreeMap::new();
|
|
for pin in pins {
|
|
if replacement.insert(pin.id.clone(), pin).is_some() {
|
|
return Err(KernelError::Invalid("duplicate resolution pin id".into()));
|
|
}
|
|
}
|
|
crate::resolution::validate_pins(&campaign, &replacement)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
let previous_epoch = campaign.resolution_policy.resolution_epoch;
|
|
campaign.resolution_pins = replacement;
|
|
campaign.resolution_policy.resolution_epoch = previous_epoch.saturating_add(1);
|
|
campaign.resolution_cover = None;
|
|
commit_resolution_control(
|
|
store,
|
|
row,
|
|
campaign,
|
|
previous_epoch,
|
|
"replace_resolution_pins",
|
|
)
|
|
}
|
|
WorldCommand::FissionGestalt {
|
|
expected_revision,
|
|
preview,
|
|
evidence_receipts,
|
|
model_stage_receipts,
|
|
} => {
|
|
require_revision(&campaign, expected_revision)?;
|
|
let supplied_evidence: BTreeSet<_> = evidence_receipts
|
|
.iter()
|
|
.map(|receipt| receipt.id.clone())
|
|
.collect();
|
|
if preview
|
|
.evidence_receipt_ids
|
|
.iter()
|
|
.any(|id| !supplied_evidence.contains(id))
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"fission preview evidence receipts were not supplied".into(),
|
|
));
|
|
}
|
|
let transition = crate::legacy_transition::lower_fission(
|
|
&campaign,
|
|
&preview,
|
|
Utc::now() + Duration::minutes(5),
|
|
)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
let mutation_receipt = crate::legacy_transition::apply_lowered_fission(
|
|
&mut campaign,
|
|
&preview,
|
|
&transition,
|
|
Utc::now(),
|
|
)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
for candidate in &preview.canon_candidates {
|
|
campaign
|
|
.canon_candidates
|
|
.insert(candidate.id.clone(), candidate.clone());
|
|
}
|
|
commit_with_records(
|
|
store,
|
|
row,
|
|
campaign,
|
|
"fission_gestalt",
|
|
evidence_receipts,
|
|
preview.canon_candidates,
|
|
model_stage_receipts,
|
|
Some((transition, mutation_receipt)),
|
|
)
|
|
}
|
|
WorldCommand::AdvanceStrategicTick {
|
|
expected_revision,
|
|
source,
|
|
plan,
|
|
model_receipt_hash,
|
|
resolution_wave,
|
|
} => {
|
|
require_revision(&campaign, expected_revision)?;
|
|
if plan.is_some() && resolution_wave.is_some() {
|
|
return Err(KernelError::Invalid(
|
|
"strategic tick has two competing plan authorities".into(),
|
|
));
|
|
}
|
|
let resolved_plan = resolution_wave
|
|
.as_ref()
|
|
.map(|wave| crate::resolution::validate_and_resolve_wave(&campaign, wave))
|
|
.transpose()
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
let external_subject_ids = store
|
|
.load_all::<crate::consumer::ExternalSubjectAuthority>(
|
|
"external_subject_authority.v1",
|
|
)
|
|
.map_err(persist)?
|
|
.into_iter()
|
|
.map(|authority| authority.subject_id)
|
|
.collect::<BTreeSet<_>>();
|
|
if resolved_plan
|
|
.as_ref()
|
|
.or(plan.as_ref())
|
|
.is_some_and(|plan| {
|
|
strategic_plan_writes_external_subject(plan, &external_subject_ids)
|
|
})
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"strategic resolution cannot mutate an external subject or bypass its proposal boundary".into(),
|
|
));
|
|
}
|
|
if (plan.is_some() || resolution_wave.is_some())
|
|
&& model_receipt_hash
|
|
.as_deref()
|
|
.is_none_or(|hash| !valid_sha256(hash))
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"model-driven strategic tick lacks an exact model receipt hash".into(),
|
|
));
|
|
}
|
|
if let Some(wave) = &resolution_wave {
|
|
let unique_hashes: BTreeSet<_> = wave.model_receipt_hashes.iter().collect();
|
|
let action_count = wave
|
|
.appraisals
|
|
.iter()
|
|
.map(|appraisal| appraisal.actions.len())
|
|
.sum::<usize>();
|
|
let outcome_digests = resolved_plan
|
|
.as_ref()
|
|
.map(crate::outcome::plan_activity_digests)
|
|
.unwrap_or_default();
|
|
let outcome_stage_count = outcome_digests.len();
|
|
if unique_hashes.len() != wave.model_receipt_hashes.len()
|
|
|| wave.model_receipt_hashes.len()
|
|
< wave
|
|
.cover
|
|
.cells
|
|
.len()
|
|
.saturating_mul(3)
|
|
.saturating_add(action_count)
|
|
.saturating_add(outcome_stage_count)
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"resolution wave does not carry one distinct stage receipt per cell stage"
|
|
.into(),
|
|
));
|
|
}
|
|
let mut stage_bindings = BTreeSet::new();
|
|
for hash in &wave.model_receipt_hashes {
|
|
let Some((_, receipt)) = store
|
|
.load::<crate::model::ModelStageReceipt>("persona_stage_receipt.v1", hash)
|
|
.map_err(persist)?
|
|
else {
|
|
return Err(KernelError::Invalid(
|
|
"resolution wave references an unknown model receipt".into(),
|
|
));
|
|
};
|
|
if receipt.storage_key() != hash {
|
|
return Err(KernelError::Invalid(
|
|
"resolution wave contains a mismatched model receipt".into(),
|
|
));
|
|
}
|
|
if receipt.validation_result == "valid" {
|
|
stage_bindings
|
|
.insert((receipt.stage.clone(), receipt.snapshot_binding.clone()));
|
|
}
|
|
}
|
|
for cell in &wave.cover.cells {
|
|
let binding = format!(
|
|
"campaign:{}:revision:{}:resolution:{}:cell:{}",
|
|
campaign.id,
|
|
campaign.revision,
|
|
campaign.resolution_policy.resolution_epoch,
|
|
cell.id
|
|
);
|
|
for stage in ["cell_projector", "cell_persona", "cell_interpreter"] {
|
|
if !stage_bindings.contains(&(stage.into(), binding.clone())) {
|
|
return Err(KernelError::Invalid(format!(
|
|
"resolution wave lacks {stage} receipt for {}",
|
|
cell.id
|
|
)));
|
|
}
|
|
}
|
|
let actionful = wave
|
|
.appraisals
|
|
.iter()
|
|
.find(|appraisal| appraisal.cell_id == cell.id)
|
|
.is_some_and(|appraisal| !appraisal.actions.is_empty());
|
|
if actionful {
|
|
let appraisal = wave
|
|
.appraisals
|
|
.iter()
|
|
.find(|appraisal| appraisal.cell_id == cell.id)
|
|
.expect("active cell appraisal was validated");
|
|
for action in &appraisal.actions {
|
|
let verifier_binding =
|
|
crate::persona::cell_effect_verification_binding(
|
|
&binding,
|
|
std::slice::from_ref(action),
|
|
)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
if !stage_bindings
|
|
.contains(&("cell_effect_verifier".into(), verifier_binding))
|
|
{
|
|
return Err(KernelError::Invalid(format!(
|
|
"resolution wave lacks action-bound cell_effect_verifier receipt for {} action by {}",
|
|
cell.id, action.subject_id
|
|
)));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for binding in expected_activity_outcome_bindings(&campaign, &outcome_digests) {
|
|
if !stage_bindings.contains(&("strategic_outcome_resolver".into(), binding)) {
|
|
return Err(KernelError::Invalid(
|
|
"resolution wave lacks an activity-bound strategic outcome receipt"
|
|
.into(),
|
|
));
|
|
}
|
|
}
|
|
if !wave.strategic_individuations.is_empty() {
|
|
let selected_actions = resolved_plan
|
|
.as_ref()
|
|
.map(|plan| plan.selected_actions.as_slice())
|
|
.unwrap_or_default();
|
|
let candidate_digests =
|
|
crate::scheduler::strategic_individuation_candidate_digests(
|
|
&campaign,
|
|
selected_actions,
|
|
);
|
|
for proposal in &wave.strategic_individuations {
|
|
let proposal_digest =
|
|
crate::scheduler::strategic_individuation_proposal_digest(proposal)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
let binding = crate::scheduler::strategic_individuation_binding(
|
|
&campaign,
|
|
&candidate_digests,
|
|
Some(&proposal_digest),
|
|
);
|
|
if !stage_bindings
|
|
.contains(&("strategic_individuation_selector".into(), binding))
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"strategic individuation lacks a payload-bound selector receipt"
|
|
.into(),
|
|
));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if let Some(wave) = &resolution_wave {
|
|
for proposal in &wave.strategic_individuations {
|
|
apply_individuation(&mut campaign, &proposal.individuation)?;
|
|
}
|
|
}
|
|
let individuation_public_channels = resolved_plan
|
|
.as_ref()
|
|
.or(plan.as_ref())
|
|
.map(|plan| {
|
|
plan.selected_actions
|
|
.iter()
|
|
.map(|action| {
|
|
crate::resolution::cell_action_digest(action)
|
|
.map(|digest| (digest, action.public_channels.clone()))
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))
|
|
})
|
|
.collect::<Result<BTreeMap<_, _>, _>>()
|
|
})
|
|
.transpose()?
|
|
.unwrap_or_default();
|
|
let applied_tick = match resolved_plan.or(plan) {
|
|
Some(plan) => apply_strategic_tick_plan(&mut campaign, plan)?,
|
|
None => {
|
|
let plan = deterministic_strategic_tick_plan();
|
|
apply_strategic_tick_plan(&mut campaign, plan)?
|
|
}
|
|
};
|
|
let AppliedStrategicTickPlan {
|
|
events: mut tick_events,
|
|
mutation,
|
|
} = applied_tick;
|
|
if let Some(wave) = &resolution_wave {
|
|
for proposal in &wave.strategic_individuations {
|
|
let member = &proposal.individuation.member;
|
|
let gestalt_name = campaign
|
|
.gestalts
|
|
.get(&proposal.individuation.gestalt_id)
|
|
.map(|gestalt| gestalt.name.as_str())
|
|
.unwrap_or("their community");
|
|
let undertaking = member
|
|
.goals
|
|
.first()
|
|
.map(String::as_str)
|
|
.or_else(|| member.obligations.iter().next().map(String::as_str));
|
|
let summary = undertaking.map_or_else(
|
|
|| format!("{} steps forward within {gestalt_name}.", member.name),
|
|
|undertaking| {
|
|
format!(
|
|
"{} steps forward within {gestalt_name} to {undertaking}.",
|
|
member.name
|
|
)
|
|
},
|
|
);
|
|
tick_events.push(crate::domain::Event {
|
|
id: format!(
|
|
"strategic:{}:individuation:{}",
|
|
campaign.strategic_tick_count.saturating_add(1),
|
|
crate::domain::canonical_gestalt_member_local_id(&member.id)
|
|
),
|
|
at: campaign.world_time,
|
|
kind: "gestalt_individuation".into(),
|
|
summary: summary.chars().take(240).collect(),
|
|
actor_ids: vec![crate::domain::gestalt_member_subject_id(&member.id)],
|
|
institution_ids: vec![],
|
|
gestalt_ids: vec![proposal.individuation.gestalt_id.clone()],
|
|
location_ids: vec![proposal.individuation.location_id.clone()],
|
|
public_channels: individuation_public_channels
|
|
.get(&proposal.action_digest)
|
|
.cloned()
|
|
.unwrap_or_default(),
|
|
});
|
|
}
|
|
}
|
|
if let Some(wave) = &resolution_wave {
|
|
crate::resolution::advance_detail_debt(&mut campaign, &wave.cover);
|
|
campaign.resolution_cover = Some(wave.cover.clone());
|
|
}
|
|
campaign.strategic_tick_count = campaign.strategic_tick_count.saturating_add(1);
|
|
for event in &tick_events {
|
|
for channel in &event.public_channels {
|
|
campaign.news.push(crate::domain::NewsIssue {
|
|
id: format!("news:{}:{}", event.id, stable_channel_id(channel)),
|
|
at: campaign.world_time,
|
|
channel: channel.clone(),
|
|
headline: crate::domain::committed_news_headline(&event.summary),
|
|
event_ids: vec![event.id.clone()],
|
|
reliability: "committed public channel".into(),
|
|
});
|
|
}
|
|
}
|
|
let event_ids = tick_events.iter().map(|event| event.id.clone()).collect();
|
|
campaign.events.extend(tick_events);
|
|
if source == TickSource::PlayerWait {
|
|
campaign.last_player_activity = Utc::now();
|
|
campaign.away_ticks_processed = 0;
|
|
campaign.pending_ticks = 0;
|
|
} else {
|
|
campaign.away_ticks_processed =
|
|
campaign.away_ticks_processed.saturating_add(1).min(8);
|
|
campaign.pending_ticks = campaign.pending_ticks.saturating_sub(1);
|
|
}
|
|
commit_strategic_tick(
|
|
store,
|
|
row,
|
|
campaign,
|
|
source,
|
|
model_receipt_hash,
|
|
event_ids,
|
|
resolution_wave,
|
|
mutation,
|
|
)
|
|
}
|
|
WorldCommand::ExpandRegion {
|
|
expected_revision,
|
|
expansion,
|
|
evidence_receipts,
|
|
canon_candidates,
|
|
model_stage_receipts,
|
|
} => {
|
|
require_revision(&campaign, expected_revision)?;
|
|
validate_region_admission_evidence(&expansion, &evidence_receipts, &canon_candidates)?;
|
|
crate::compiler::validate_new_destination_expansion(&campaign, &expansion)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
validate_civic_admission_receipt(&campaign, &expansion, &model_stage_receipts)?;
|
|
let transition = crate::legacy_transition::lower_region_expansion(
|
|
&campaign,
|
|
&expansion,
|
|
Utc::now() + Duration::minutes(5),
|
|
)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
let mutation_receipt = crate::legacy_transition::apply_lowered_region_expansion(
|
|
&mut campaign,
|
|
&expansion,
|
|
&transition,
|
|
Utc::now(),
|
|
)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
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,
|
|
model_stage_receipts,
|
|
Some((transition, mutation_receipt)),
|
|
)
|
|
}
|
|
WorldCommand::ElaborateLocality {
|
|
expected_revision,
|
|
elaboration,
|
|
evidence_receipts,
|
|
canon_candidates,
|
|
model_stage_receipts,
|
|
} => {
|
|
require_revision(&campaign, expected_revision)?;
|
|
validate_region_admission_evidence(
|
|
&elaboration.expansion,
|
|
&evidence_receipts,
|
|
&canon_candidates,
|
|
)?;
|
|
crate::compiler::validate_locality_elaboration(&campaign, &elaboration)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
validate_civic_admission_receipt(
|
|
&campaign,
|
|
&elaboration.expansion,
|
|
&model_stage_receipts,
|
|
)?;
|
|
let transition = crate::legacy_transition::lower_region_expansion(
|
|
&campaign,
|
|
&elaboration.expansion,
|
|
Utc::now() + Duration::minutes(5),
|
|
)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
let mutation_receipt = crate::legacy_transition::apply_lowered_region_expansion(
|
|
&mut campaign,
|
|
&elaboration.expansion,
|
|
&transition,
|
|
Utc::now(),
|
|
)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
for candidate in &canon_candidates {
|
|
campaign
|
|
.canon_candidates
|
|
.insert(candidate.id.clone(), candidate.clone());
|
|
}
|
|
commit_with_records(
|
|
store,
|
|
row,
|
|
campaign,
|
|
"elaborate_locality",
|
|
evidence_receipts,
|
|
canon_candidates,
|
|
model_stage_receipts,
|
|
Some((transition, mutation_receipt)),
|
|
)
|
|
}
|
|
WorldCommand::MaterializeGestaltMember {
|
|
expected_revision,
|
|
gestalt_id,
|
|
expected_gestalt_version,
|
|
member_id,
|
|
expected_member_version,
|
|
location_id,
|
|
} => {
|
|
require_revision(&campaign, expected_revision)?;
|
|
let before = campaign.clone();
|
|
apply_promotion(
|
|
&mut campaign,
|
|
&GestaltPromotion {
|
|
gestalt_id,
|
|
expected_gestalt_version,
|
|
member_id,
|
|
expected_member_version,
|
|
location_id,
|
|
},
|
|
)?;
|
|
commit_gestalt_presence(
|
|
store,
|
|
row,
|
|
before,
|
|
campaign,
|
|
"materialize_gestalt_member",
|
|
"direct materialization command",
|
|
)
|
|
}
|
|
WorldCommand::IndividuateGestaltMember {
|
|
expected_revision,
|
|
individuation,
|
|
} => {
|
|
require_revision(&campaign, expected_revision)?;
|
|
let before = campaign.clone();
|
|
apply_individuation(&mut campaign, &individuation)?;
|
|
commit_gestalt_presence(
|
|
store,
|
|
row,
|
|
before,
|
|
campaign,
|
|
"individuate_gestalt_member",
|
|
"direct individuation command",
|
|
)
|
|
}
|
|
WorldCommand::DematerializeGestaltMember {
|
|
expected_revision,
|
|
actor_id,
|
|
} => {
|
|
require_revision(&campaign, expected_revision)?;
|
|
let before = campaign.clone();
|
|
apply_demotion(&mut campaign, &GestaltDemotion { actor_id })?;
|
|
commit_gestalt_presence(
|
|
store,
|
|
row,
|
|
before,
|
|
campaign,
|
|
"dematerialize_gestalt_member",
|
|
"direct dematerialization command",
|
|
)
|
|
}
|
|
WorldCommand::ReconcileGestaltPresence {
|
|
expected_revision,
|
|
reason,
|
|
plan,
|
|
} => {
|
|
require_revision(&campaign, expected_revision)?;
|
|
if reason.trim().is_empty() {
|
|
return Err(KernelError::Invalid("presence plan has no reason".into()));
|
|
}
|
|
if !plan.individuations.is_empty()
|
|
&& crate::gestalt::automatic_individuation_stimulus(&campaign).as_deref()
|
|
!= Some(reason.as_str())
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"automatic individuation is admitted only by the exact immediately committed player speech"
|
|
.into(),
|
|
));
|
|
}
|
|
if plan.individuations.len() > 1 {
|
|
return Err(KernelError::Invalid(
|
|
"one player speech can admit at most one first-relevance person".into(),
|
|
));
|
|
}
|
|
let addressed_public_identities =
|
|
crate::gestalt::automatic_individuation_addressed_actor_ids(&campaign)
|
|
.iter()
|
|
.filter_map(|actor_id| campaign.actors.get(actor_id))
|
|
.map(|actor| actor.name.trim().to_lowercase())
|
|
.collect::<BTreeSet<_>>();
|
|
if plan.individuations.iter().any(|individuation| {
|
|
addressed_public_identities
|
|
.contains(&individuation.member.name.trim().to_lowercase())
|
|
}) {
|
|
return Err(KernelError::Invalid(
|
|
"presence individuation duplicates an already-addressed actor".into(),
|
|
));
|
|
}
|
|
let player_location = &campaign.actors[&campaign.player_actor_id].location_id;
|
|
if plan
|
|
.individuations
|
|
.iter()
|
|
.any(|entry| &entry.location_id != player_location)
|
|
|| plan
|
|
.promotions
|
|
.iter()
|
|
.any(|entry| &entry.location_id != player_location)
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"automatic presence reconciliation is confined to the player's active location"
|
|
.into(),
|
|
));
|
|
}
|
|
let before = campaign.clone();
|
|
let mut candidate = campaign.clone();
|
|
for demotion in &plan.demotions {
|
|
apply_demotion(&mut candidate, demotion)?;
|
|
}
|
|
for individuation in &plan.individuations {
|
|
apply_individuation(&mut candidate, individuation)?;
|
|
}
|
|
for promotion in &plan.promotions {
|
|
apply_promotion(&mut candidate, promotion)?;
|
|
}
|
|
commit_gestalt_presence(
|
|
store,
|
|
row,
|
|
before,
|
|
candidate,
|
|
"reconcile_gestalt_presence",
|
|
&reason,
|
|
)
|
|
}
|
|
WorldCommand::ResolveReactionWave {
|
|
expected_revision,
|
|
event_summary,
|
|
reactions,
|
|
gestalt_reactions,
|
|
} => {
|
|
require_revision(&campaign, expected_revision)?;
|
|
let witnessed_turn = canonical_witnessed_turn(&campaign, &event_summary)?;
|
|
let response_expected_actor_ids = witnessed_turn.persona_response_actor_ids.clone();
|
|
let witnessed_memory = format!("Witnessed: {}", canonical_turn_text(witnessed_turn));
|
|
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()));
|
|
}
|
|
if !reaction.private_delta.memories_add.is_empty() {
|
|
return Err(KernelError::Invalid(
|
|
"reaction Interpreter cannot write actor memory".into(),
|
|
));
|
|
}
|
|
if let Some(identity) = reaction.private_delta.identity_adoption.as_deref() {
|
|
validate_bounded_text("reaction identity adoption", identity, 160)?;
|
|
let speech = reaction.speech.as_deref().ok_or_else(|| {
|
|
KernelError::Invalid(
|
|
"reaction identity adoption requires public speech".into(),
|
|
)
|
|
})?;
|
|
if !speech.to_lowercase().contains(&identity.to_lowercase()) {
|
|
return Err(KernelError::Invalid(
|
|
"reaction identity adoption must copy an exact spoken handle".into(),
|
|
));
|
|
}
|
|
validate_reaction_identity_adoption(&campaign, &reaction.actor_id, identity)?;
|
|
}
|
|
if let Some(speech) = &reaction.speech {
|
|
validate_bounded_text("reaction speech", speech, 1_000)?;
|
|
}
|
|
for proposal in &reaction.action_proposals {
|
|
validate_world_proposal(actor, proposal)?;
|
|
}
|
|
}
|
|
let mut seen_gestalts = BTreeSet::new();
|
|
for reaction in &gestalt_reactions {
|
|
if !seen_gestalts.insert(reaction.gestalt_id.clone()) {
|
|
return Err(KernelError::Invalid(
|
|
"Gestalt reacted twice in one wave".into(),
|
|
));
|
|
}
|
|
if seen.contains(&reaction.gestalt_id) {
|
|
return Err(KernelError::Invalid(
|
|
"reaction subject appeared as both actor and Gestalt".into(),
|
|
));
|
|
}
|
|
crate::resolution::validate_active_gestalt_presence_location(
|
|
&campaign,
|
|
&reaction.gestalt_id,
|
|
&player_location,
|
|
)
|
|
.map_err(|_| KernelError::Invalid("reaction Gestalt is not present".into()))?;
|
|
if let Some(speech) = &reaction.speech {
|
|
validate_bounded_text("Gestalt reaction speech", speech, 1_000)?;
|
|
}
|
|
}
|
|
for response_actor_id in &response_expected_actor_ids {
|
|
let actor_reaction = reactions
|
|
.iter()
|
|
.find(|reaction| &reaction.actor_id == response_actor_id);
|
|
let gestalt_reaction = gestalt_reactions
|
|
.iter()
|
|
.find(|reaction| &reaction.gestalt_id == response_actor_id);
|
|
let observable = actor_reaction.is_some_and(|reaction| {
|
|
reaction
|
|
.speech
|
|
.as_deref()
|
|
.is_some_and(|value| !value.trim().is_empty())
|
|
|| reaction.deliberate_silence
|
|
}) || gestalt_reaction.is_some_and(|reaction| {
|
|
reaction
|
|
.speech
|
|
.as_deref()
|
|
.is_some_and(|value| !value.trim().is_empty())
|
|
|| reaction.deliberate_silence
|
|
});
|
|
if !observable {
|
|
return Err(KernelError::Invalid(
|
|
"directly addressed Persona is absent or produced no observable response"
|
|
.into(),
|
|
));
|
|
}
|
|
}
|
|
let source_receipt_id = format!(
|
|
"reaction-input:{}",
|
|
crate::legacy_transition::digest_serializable(&(&reactions, &gestalt_reactions))
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?
|
|
);
|
|
let transition = crate::legacy_transition::lower_reaction_wave(
|
|
&campaign,
|
|
&witnessed_memory,
|
|
&reactions,
|
|
&source_receipt_id,
|
|
Utc::now() + Duration::minutes(5),
|
|
)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
let mutation_receipt = crate::legacy_transition::apply_lowered_transition(
|
|
&mut campaign,
|
|
&transition,
|
|
Utc::now(),
|
|
)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
campaign.pending_world_proposals.clear();
|
|
for reaction in reactions {
|
|
if let Some(speech) = reaction.speech {
|
|
campaign.transcript.push(NarrativeTurn {
|
|
revision: campaign.revision + 1,
|
|
at: Utc::now(),
|
|
speaker: reaction.actor_id.clone(),
|
|
text: speech,
|
|
persona_response_actor_ids: BTreeSet::new(),
|
|
});
|
|
}
|
|
if reaction.deliberate_silence {
|
|
campaign.transcript.push(NarrativeTurn {
|
|
revision: campaign.revision + 1,
|
|
at: Utc::now(),
|
|
speaker: reaction.actor_id.clone(),
|
|
text: "deliberately does not answer.".into(),
|
|
persona_response_actor_ids: BTreeSet::new(),
|
|
});
|
|
}
|
|
campaign
|
|
.pending_world_proposals
|
|
.extend(reaction.action_proposals);
|
|
}
|
|
for reaction in gestalt_reactions {
|
|
if let Some(speech) = reaction.speech {
|
|
campaign.transcript.push(NarrativeTurn {
|
|
revision: campaign.revision + 1,
|
|
at: Utc::now(),
|
|
speaker: reaction.gestalt_id.clone(),
|
|
text: speech,
|
|
persona_response_actor_ids: BTreeSet::new(),
|
|
});
|
|
}
|
|
if reaction.deliberate_silence {
|
|
campaign.transcript.push(NarrativeTurn {
|
|
revision: campaign.revision + 1,
|
|
at: Utc::now(),
|
|
speaker: reaction.gestalt_id,
|
|
text: "deliberately does not answer.".into(),
|
|
persona_response_actor_ids: BTreeSet::new(),
|
|
});
|
|
}
|
|
}
|
|
refresh_materialized_member_relevance(&mut campaign, seen.iter().map(String::as_str));
|
|
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![],
|
|
gestalt_ids: seen_gestalts.into_iter().collect(),
|
|
location_ids: vec![player_location],
|
|
public_channels: vec![],
|
|
});
|
|
commit_mutation_transition(
|
|
store,
|
|
row,
|
|
campaign,
|
|
"reaction_wave",
|
|
None,
|
|
transition,
|
|
mutation_receipt,
|
|
)
|
|
}
|
|
WorldCommand::ResolveNpcAction {
|
|
expected_revision,
|
|
proposal,
|
|
assessment,
|
|
} => {
|
|
require_revision(&campaign, expected_revision)?;
|
|
let current_window_id = format!("reaction-wave:{}", campaign.revision);
|
|
if campaign
|
|
.events
|
|
.last()
|
|
.is_none_or(|event| event.kind != "reaction_wave" || event.id != current_window_id)
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"pending NPC initiative does not belong to the current reaction wave".into(),
|
|
));
|
|
}
|
|
let selected = crate::initiative::winner(&campaign.pending_world_proposals)
|
|
.ok_or_else(|| KernelError::Invalid("there is no pending NPC action".into()))?;
|
|
if proposal != selected {
|
|
return Err(KernelError::Invalid(
|
|
"proposal does not own the current initiative opportunity".into(),
|
|
));
|
|
}
|
|
let actor = campaign
|
|
.actors
|
|
.get(&proposal.actor_id)
|
|
.ok_or_else(|| KernelError::Invalid("initiative actor is unknown".into()))?;
|
|
validate_world_proposal(actor, &proposal)?;
|
|
let intent = ActionIntent {
|
|
actor_id: proposal.actor_id.clone(),
|
|
description: proposal.intent.clone(),
|
|
intended_effect: proposal.intended_effect.clone(),
|
|
};
|
|
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(
|
|
"NPC assessment is stale or invalid".into(),
|
|
));
|
|
}
|
|
for (effect, stake) in [
|
|
(&assessment.strong_effect, &assessment.success_stake),
|
|
(&assessment.success_effect, &assessment.success_stake),
|
|
(&assessment.mixed_effect, &assessment.mixed_stake),
|
|
(&assessment.failure_effect, &assessment.failure_stake),
|
|
] {
|
|
crate::assessor::validate_effect(&campaign, actor, effect, stake)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
validate_bounded_coop_effect(store, &campaign, &proposal.actor_id, effect)?;
|
|
}
|
|
let actor_name = actor.name.clone();
|
|
let actor_location = actor.location_id.clone();
|
|
campaign.pending_world_proposals.clear();
|
|
let roll = if assessment.admissible {
|
|
let roll = receipt(
|
|
assessment.digest.clone(),
|
|
rand::rng().random_range(1..=20),
|
|
assessment.modifier_total,
|
|
assessment.dc,
|
|
);
|
|
let (text, effect) = match roll.outcome {
|
|
OutcomeBand::StrongSuccess => {
|
|
(&assessment.success_stake, &assessment.strong_effect)
|
|
}
|
|
OutcomeBand::Success => (&assessment.success_stake, &assessment.success_effect),
|
|
OutcomeBand::Mixed => (&assessment.mixed_stake, &assessment.mixed_effect),
|
|
OutcomeBand::Failure => (&assessment.failure_stake, &assessment.failure_effect),
|
|
};
|
|
let transition = crate::legacy_transition::lower_foreground_effect(
|
|
&campaign,
|
|
&proposal.actor_id,
|
|
effect,
|
|
roll.outcome.clone(),
|
|
crate::transition::MutationProcedure::NpcAttempt,
|
|
&assessment.effect_ceiling,
|
|
&assessment.digest,
|
|
Some(
|
|
crate::legacy_transition::digest_serializable(&intent)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?,
|
|
),
|
|
Some(
|
|
crate::legacy_transition::digest_serializable(&intent.intended_effect)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?,
|
|
),
|
|
assessment.expires_at,
|
|
)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
let mutation_receipt = crate::legacy_transition::apply_lowered_transition(
|
|
&mut campaign,
|
|
&transition,
|
|
Utc::now(),
|
|
)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
campaign.transcript.push(NarrativeTurn {
|
|
revision: campaign.revision + 1,
|
|
at: Utc::now(),
|
|
speaker: "world".into(),
|
|
text: text.clone(),
|
|
persona_response_actor_ids: BTreeSet::new(),
|
|
});
|
|
Some((roll, transition, mutation_receipt))
|
|
} else {
|
|
None
|
|
};
|
|
campaign.events.push(Event {
|
|
id: format!("npc-action-resolved:{}", campaign.revision + 1),
|
|
at: campaign.world_time,
|
|
kind: "npc_action_resolved".into(),
|
|
summary: if assessment.admissible {
|
|
format!("{} attempts {}", actor_name, proposal.intent)
|
|
} else {
|
|
format!("{} cannot yet attempt {}", actor_name, proposal.intent)
|
|
},
|
|
actor_ids: vec![proposal.actor_id.clone()],
|
|
institution_ids: vec![],
|
|
gestalt_ids: vec![],
|
|
location_ids: vec![actor_location],
|
|
public_channels: vec![],
|
|
});
|
|
refresh_materialized_member_relevance(
|
|
&mut campaign,
|
|
std::iter::once(proposal.actor_id.as_str()),
|
|
);
|
|
if let Some((roll, transition, mutation_receipt)) = roll {
|
|
commit_mutation_transition(
|
|
store,
|
|
row,
|
|
campaign,
|
|
"resolve_npc_action",
|
|
Some(roll),
|
|
transition,
|
|
mutation_receipt,
|
|
)
|
|
} else {
|
|
commit(store, row, campaign, "resolve_npc_action", None)
|
|
}
|
|
}
|
|
WorldCommand::CreateCampaign { .. } => unreachable!(),
|
|
}
|
|
}
|
|
|
|
fn external_outcome_writes_subject(
|
|
effect: &StrategicOutcomeEffect,
|
|
external_subject_ids: &BTreeSet<String>,
|
|
) -> bool {
|
|
match effect {
|
|
StrategicOutcomeEffect::ResourceCreated {
|
|
owner_subject_id, ..
|
|
}
|
|
| StrategicOutcomeEffect::ResourceConsumed {
|
|
owner_subject_id, ..
|
|
}
|
|
| StrategicOutcomeEffect::KnowledgeLearned {
|
|
owner_subject_id, ..
|
|
} => external_subject_ids.contains(owner_subject_id),
|
|
StrategicOutcomeEffect::ResourceTransferred {
|
|
from_subject_id,
|
|
to_subject_id,
|
|
..
|
|
} => {
|
|
external_subject_ids.contains(from_subject_id)
|
|
|| external_subject_ids.contains(to_subject_id)
|
|
}
|
|
StrategicOutcomeEffect::KnowledgeCommunicated { to_subject_ids, .. } => to_subject_ids
|
|
.iter()
|
|
.any(|subject_id| external_subject_ids.contains(subject_id)),
|
|
StrategicOutcomeEffect::NoMaterialChange { .. }
|
|
| StrategicOutcomeEffect::GestaltPressure { .. }
|
|
| StrategicOutcomeEffect::AgencyRelationShift { .. }
|
|
| StrategicOutcomeEffect::MemberMemory { .. }
|
|
| StrategicOutcomeEffect::MemberObligation { .. }
|
|
| StrategicOutcomeEffect::MemberRelationship { .. } => false,
|
|
}
|
|
}
|
|
|
|
fn strategic_plan_writes_external_subject(
|
|
plan: &StrategicTickPlan,
|
|
external_subject_ids: &BTreeSet<String>,
|
|
) -> bool {
|
|
plan.selected_actions.iter().any(|action| {
|
|
crate::consumer::proposal_targets(action)
|
|
.iter()
|
|
.any(|target| external_subject_ids.contains(*target))
|
|
}) || plan
|
|
.institution_actions
|
|
.iter()
|
|
.any(|action| external_subject_ids.contains(&action.institution_id))
|
|
|| plan
|
|
.activity_outcomes
|
|
.iter()
|
|
.any(|outcome| external_outcome_writes_subject(&outcome.effect, external_subject_ids))
|
|
}
|
|
|
|
fn expected_activity_outcome_bindings(
|
|
campaign: &Campaign,
|
|
action_digests: &[String],
|
|
) -> Vec<String> {
|
|
action_digests
|
|
.iter()
|
|
.map(|digest| {
|
|
crate::outcome::activity_outcome_binding(
|
|
campaign.id,
|
|
campaign.revision,
|
|
campaign.resolution_policy.resolution_epoch,
|
|
std::slice::from_ref(digest),
|
|
)
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
fn validate_intent_text(intent: &ActionIntent) -> Result<(), KernelError> {
|
|
validate_bounded_text("action description", &intent.description, 4_000)?;
|
|
validate_bounded_text("intended effect", &intent.intended_effect, 1_000)
|
|
}
|
|
|
|
fn validate_bounded_text(label: &str, value: &str, max_chars: usize) -> Result<(), KernelError> {
|
|
if value.trim().is_empty()
|
|
|| value.chars().count() > max_chars
|
|
|| value
|
|
.chars()
|
|
.any(|character| character.is_control() && !matches!(character, '\n' | '\r' | '\t'))
|
|
{
|
|
return Err(KernelError::Invalid(format!(
|
|
"{label} must contain 1 to {max_chars} readable characters"
|
|
)));
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn apply_individuation(
|
|
campaign: &mut Campaign,
|
|
individuation: &GestaltIndividuation,
|
|
) -> Result<(), KernelError> {
|
|
let mut member = individuation.member.clone();
|
|
member.id = crate::domain::canonical_gestalt_member_local_id(&member.id);
|
|
let gestalt = campaign
|
|
.gestalts
|
|
.get(&individuation.gestalt_id)
|
|
.ok_or_else(|| KernelError::Invalid("gestalt is unknown".into()))?;
|
|
crate::resolution::validate_active_gestalt_presence_location(
|
|
campaign,
|
|
&individuation.gestalt_id,
|
|
&individuation.location_id,
|
|
)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
if gestalt.version != individuation.expected_gestalt_version
|
|
|| member.gestalt_id != individuation.gestalt_id
|
|
|| member.version != 0
|
|
|| member.materialized_actor_id.is_some()
|
|
|| member.id.trim().is_empty()
|
|
|| member.name.trim().is_empty()
|
|
|| campaign.gestalt_members.contains_key(&member.id)
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"gestalt individuation is stale or malformed".into(),
|
|
));
|
|
}
|
|
campaign
|
|
.gestalt_members
|
|
.insert(member.id.clone(), member.clone());
|
|
apply_promotion(
|
|
campaign,
|
|
&GestaltPromotion {
|
|
gestalt_id: individuation.gestalt_id.clone(),
|
|
expected_gestalt_version: individuation.expected_gestalt_version,
|
|
member_id: member.id.clone(),
|
|
expected_member_version: 0,
|
|
location_id: individuation.location_id.clone(),
|
|
},
|
|
)
|
|
}
|
|
|
|
fn apply_promotion(
|
|
campaign: &mut Campaign,
|
|
promotion: &GestaltPromotion,
|
|
) -> Result<(), KernelError> {
|
|
if !campaign.locations.contains_key(&promotion.location_id) {
|
|
return Err(KernelError::Invalid(
|
|
"materialization location is unknown".into(),
|
|
));
|
|
}
|
|
crate::resolution::validate_active_gestalt_presence_location(
|
|
campaign,
|
|
&promotion.gestalt_id,
|
|
&promotion.location_id,
|
|
)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
let gestalt = campaign
|
|
.gestalts
|
|
.get(&promotion.gestalt_id)
|
|
.ok_or_else(|| KernelError::Invalid("gestalt is unknown".into()))?
|
|
.clone();
|
|
if gestalt.version != promotion.expected_gestalt_version {
|
|
return Err(KernelError::Invalid("gestalt snapshot is stale".into()));
|
|
}
|
|
let member_location =
|
|
crate::resolution::dormant_member_location(campaign, &promotion.member_id)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
if member_location != promotion.location_id {
|
|
return Err(KernelError::Invalid(
|
|
"gestalt member cannot materialize outside their exact location".into(),
|
|
));
|
|
}
|
|
let member = campaign
|
|
.gestalt_members
|
|
.get_mut(&promotion.member_id)
|
|
.ok_or_else(|| KernelError::Invalid("gestalt member is unknown".into()))?;
|
|
if member.gestalt_id != promotion.gestalt_id
|
|
|| member.version != promotion.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 = crate::domain::gestalt_member_subject_id(&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, &promotion.location_id);
|
|
member.materialized_actor_id = Some(actor_id.clone());
|
|
member.last_location_id = Some(promotion.location_id.clone());
|
|
member.last_relevant_revision = campaign.revision;
|
|
member.relevance_lease_until_revision = campaign
|
|
.revision
|
|
.saturating_add(GESTALT_RELEVANCE_LEASE_REVISIONS);
|
|
member.version += 1;
|
|
campaign.actors.insert(actor_id, actor);
|
|
Ok(())
|
|
}
|
|
|
|
fn apply_demotion(campaign: &mut Campaign, demotion: &GestaltDemotion) -> Result<(), KernelError> {
|
|
let actor = campaign
|
|
.actors
|
|
.get(&demotion.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(demotion.actor_id.as_str()))
|
|
.map(|member| member.id.clone())
|
|
.ok_or_else(|| KernelError::Invalid("actor is not a materialized gestalt member".into()))?;
|
|
if actor.location_id == campaign.actors[&campaign.player_actor_id].location_id {
|
|
return Err(KernelError::Invalid(
|
|
"a visible gestalt member remains individually relevant".into(),
|
|
));
|
|
}
|
|
if campaign.gestalt_members[&member_id].relevance_lease_until_revision > campaign.revision {
|
|
return Err(KernelError::Invalid(
|
|
"gestalt member relevance lease has not expired".into(),
|
|
));
|
|
}
|
|
let gestalt_id = campaign.gestalt_members[&member_id].gestalt_id.clone();
|
|
let gestalt = campaign
|
|
.gestalts
|
|
.get(&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;
|
|
campaign.actors.remove(&demotion.actor_id);
|
|
Ok(())
|
|
}
|
|
|
|
fn refresh_materialized_member_relevance<'a>(
|
|
campaign: &mut Campaign,
|
|
actor_ids: impl IntoIterator<Item = &'a str>,
|
|
) {
|
|
let actor_ids = actor_ids.into_iter().collect::<BTreeSet<_>>();
|
|
for member in campaign.gestalt_members.values_mut() {
|
|
if member
|
|
.materialized_actor_id
|
|
.as_deref()
|
|
.is_some_and(|actor_id| actor_ids.contains(actor_id))
|
|
{
|
|
member.last_relevant_revision = campaign.revision;
|
|
member.relevance_lease_until_revision = campaign
|
|
.revision
|
|
.saturating_add(GESTALT_RELEVANCE_LEASE_REVISIONS);
|
|
member.version = member.version.saturating_add(1);
|
|
}
|
|
}
|
|
}
|
|
|
|
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 validate_reaction_identity_adoption(
|
|
campaign: &Campaign,
|
|
actor_id: &str,
|
|
identity: &str,
|
|
) -> Result<(), KernelError> {
|
|
let actor = campaign
|
|
.actors
|
|
.get(actor_id)
|
|
.ok_or_else(|| KernelError::Invalid("reaction actor is unknown".into()))?;
|
|
let identity = identity.trim().to_lowercase();
|
|
if actor.name.trim().to_lowercase() == identity {
|
|
return Ok(());
|
|
}
|
|
let local_collision = campaign.actors.values().any(|peer| {
|
|
peer.id != actor_id
|
|
&& peer.location_id == actor.location_id
|
|
&& peer.name.trim().to_lowercase() == identity
|
|
});
|
|
let population_collision = campaign
|
|
.gestalt_members
|
|
.values()
|
|
.find(|member| member.materialized_actor_id.as_deref() == Some(actor_id))
|
|
.is_some_and(|member| {
|
|
campaign.gestalt_members.values().any(|peer| {
|
|
peer.id != member.id
|
|
&& peer.gestalt_id == member.gestalt_id
|
|
&& peer.name.trim().to_lowercase() == identity
|
|
})
|
|
});
|
|
if local_collision || population_collision {
|
|
return Err(KernelError::Invalid(
|
|
"reaction identity adoption conflicts with an established local or population identity"
|
|
.into(),
|
|
));
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn canonical_witnessed_turn<'a>(
|
|
campaign: &'a Campaign,
|
|
event_summary: &str,
|
|
) -> Result<&'a NarrativeTurn, KernelError> {
|
|
let event_summary = event_summary.trim();
|
|
campaign
|
|
.transcript
|
|
.iter()
|
|
.rev()
|
|
.find(|turn| canonical_turn_text(turn) == event_summary)
|
|
.ok_or_else(|| {
|
|
KernelError::Invalid(
|
|
"reaction stimulus does not match a committed transcript turn".into(),
|
|
)
|
|
})
|
|
}
|
|
|
|
fn canonical_turn_text(turn: &NarrativeTurn) -> String {
|
|
if turn.speaker == "world" {
|
|
turn.text.trim().to_owned()
|
|
} else {
|
|
format!("{} says: {}", turn.speaker, turn.text.trim())
|
|
}
|
|
}
|
|
|
|
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() {
|
|
[id] => Ok(id.clone()),
|
|
[] => Err(KernelError::NotFound),
|
|
_ => Err(KernelError::Invalid(
|
|
"a campaign store must contain exactly one campaign".into(),
|
|
)),
|
|
}
|
|
}
|
|
|
|
fn require_revision(c: &Campaign, expected: u64) -> Result<(), KernelError> {
|
|
if c.revision == expected {
|
|
Ok(())
|
|
} else {
|
|
Err(KernelError::Stale {
|
|
expected,
|
|
actual: c.revision,
|
|
})
|
|
}
|
|
}
|
|
|
|
fn validate_region_admission_evidence(
|
|
expansion: &RegionExpansion,
|
|
evidence_receipts: &[VaultEvidenceReceipt],
|
|
canon_candidates: &[CanonCandidate],
|
|
) -> Result<(), KernelError> {
|
|
let supplied_evidence = evidence_receipts
|
|
.iter()
|
|
.map(|receipt| receipt.id.as_str())
|
|
.collect::<BTreeSet<_>>();
|
|
let missing_profile_evidence = expansion
|
|
.population_profiles
|
|
.iter()
|
|
.chain(expansion.institution_profiles.iter())
|
|
.any(|profile| {
|
|
profile
|
|
.evidence_receipt_ids
|
|
.iter()
|
|
.any(|id| !supplied_evidence.contains(id.as_str()))
|
|
});
|
|
let missing_relation_evidence = expansion
|
|
.migration_relations
|
|
.iter()
|
|
.chain(expansion.local_relations.iter())
|
|
.any(|relation| {
|
|
relation
|
|
.evidence_receipt_ids
|
|
.iter()
|
|
.any(|id| !supplied_evidence.contains(id.as_str()))
|
|
});
|
|
if expansion.facts.iter().any(|fact| {
|
|
fact.evidence_receipt_ids
|
|
.iter()
|
|
.any(|id| !supplied_evidence.contains(id.as_str()))
|
|
}) || missing_profile_evidence
|
|
|| missing_relation_evidence
|
|
|| canon_candidates.iter().any(|candidate| {
|
|
candidate
|
|
.evidence_receipt_ids
|
|
.iter()
|
|
.any(|id| !supplied_evidence.contains(id.as_str()))
|
|
})
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"region admission evidence receipts were not supplied".into(),
|
|
));
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn validate_civic_admission_receipt(
|
|
campaign: &Campaign,
|
|
expansion: &RegionExpansion,
|
|
model_stage_receipts: &[crate::model::ModelStageReceipt],
|
|
) -> Result<(), KernelError> {
|
|
let Some(system) = &expansion.civic_system else {
|
|
return Ok(());
|
|
};
|
|
let candidate_digest = crate::compiler::civic_candidate_digest(expansion)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
let expected_binding = crate::compiler::civic_verifier_binding(campaign, &candidate_digest);
|
|
let receipt = model_stage_receipts
|
|
.iter()
|
|
.find(|receipt| receipt.storage_key() == system.semantic_verification_receipt_id)
|
|
.ok_or_else(|| {
|
|
KernelError::Invalid("civic admission lacks its exact semantic verifier receipt".into())
|
|
})?;
|
|
let mut rebound = receipt.clone();
|
|
rebound.rebind_snapshot(receipt.snapshot_binding.clone());
|
|
if receipt.schema != "ghostlight.persona_stage_receipt.v1"
|
|
|| receipt.stage != "destination_civic_verification"
|
|
|| receipt.validation_result != "valid"
|
|
|| receipt.local_validation_error.is_some()
|
|
|| receipt.snapshot_binding != expected_binding
|
|
|| rebound.storage_key() != receipt.storage_key()
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"civic admission semantic verifier receipt is invalid or candidate-mismatched".into(),
|
|
));
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn is_human_controlled_actor(campaign: &Campaign, actor_id: &str) -> bool {
|
|
actor_id == campaign.player_actor_id
|
|
|| campaign
|
|
.agency_profiles
|
|
.get(actor_id)
|
|
.is_some_and(|profile| !profile.simulation_eligible)
|
|
}
|
|
|
|
fn require_resolution_epoch(c: &Campaign, expected: u64) -> Result<(), KernelError> {
|
|
if c.resolution_policy.resolution_epoch != expected {
|
|
return Err(KernelError::Invalid(format!(
|
|
"stale resolution epoch: expected {expected}, actual {}",
|
|
c.resolution_policy.resolution_epoch
|
|
)));
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn assess(c: &Campaign, intent: ActionIntent) -> ActionAssessment {
|
|
let actor = c.actors.get(&intent.actor_id);
|
|
let admissible = actor.is_some() && !intent.description.trim().is_empty();
|
|
let missing = if actor.is_none() {
|
|
Some("actor does not exist in this branch".into())
|
|
} else if intent.description.trim().is_empty() {
|
|
Some("no attempt was described".into())
|
|
} else {
|
|
None
|
|
};
|
|
let modifiers = vec![];
|
|
let modifier_total = capped_modifier(modifiers.iter().map(|m: &ContextModifier| m.value));
|
|
let mut a = ActionAssessment {
|
|
schema: "ghostlight.player_action_assessment.v1".into(),
|
|
campaign_id: c.id,
|
|
revision: c.revision,
|
|
intent,
|
|
admissible,
|
|
missing_permission: missing,
|
|
dc: 15,
|
|
modifiers,
|
|
modifier_total,
|
|
effect_ceiling:
|
|
"A bounded local consequence; no unsupported world fact or custody transfer.".into(),
|
|
success_stake: "The intended local effect succeeds and the world reacts.".into(),
|
|
mixed_stake: "The effect lands with the previewed cost or complication.".into(),
|
|
failure_stake: "Opposition holds and gains a concrete advantage.".into(),
|
|
strong_effect: WorldEffectDelta::default(),
|
|
success_effect: WorldEffectDelta::default(),
|
|
mixed_effect: WorldEffectDelta::default(),
|
|
failure_effect: WorldEffectDelta::default(),
|
|
bargains: if admissible {
|
|
vec![]
|
|
} else {
|
|
vec![
|
|
"Narrow the effect, obtain access, recruit help, or accept a concrete sacrifice."
|
|
.into(),
|
|
]
|
|
},
|
|
expires_at: Utc::now() + Duration::minutes(10),
|
|
digest: String::new(),
|
|
};
|
|
let bytes = rmp_serde::to_vec_named(&a).expect("assessment serializes");
|
|
a.digest = format!("sha256:{:x}", Sha256::digest(bytes));
|
|
a
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
struct AppliedStrategicTickPlan {
|
|
events: Vec<Event>,
|
|
mutation: Option<(
|
|
crate::legacy_transition::LoweredLegacyTransition,
|
|
crate::transition::WorldMutationReceipt,
|
|
)>,
|
|
}
|
|
|
|
impl std::ops::Deref for AppliedStrategicTickPlan {
|
|
type Target = [Event];
|
|
|
|
fn deref(&self) -> &Self::Target {
|
|
&self.events
|
|
}
|
|
}
|
|
|
|
fn merge_strategic_outcome_event_context(
|
|
contexts: &mut BTreeMap<String, (String, Vec<String>, Vec<String>)>,
|
|
action_digest: &str,
|
|
subject_id: &str,
|
|
location_ids: &[String],
|
|
public_channels: &[String],
|
|
) -> Result<(), KernelError> {
|
|
let entry = contexts
|
|
.entry(action_digest.to_owned())
|
|
.or_insert_with(|| (subject_id.to_owned(), Vec::new(), Vec::new()));
|
|
if entry.0 != subject_id {
|
|
return Err(KernelError::Invalid(
|
|
"one strategic action digest cannot belong to multiple subjects".into(),
|
|
));
|
|
}
|
|
entry.1.extend(location_ids.iter().cloned());
|
|
entry.1.sort();
|
|
entry.1.dedup();
|
|
entry.2.extend(public_channels.iter().cloned());
|
|
entry.2.sort();
|
|
entry.2.dedup();
|
|
Ok(())
|
|
}
|
|
|
|
fn strategic_activity_phase(
|
|
campaign: &Campaign,
|
|
prospective_actor_locations: &BTreeMap<String, String>,
|
|
prospective_gestalt_locations: &BTreeMap<String, String>,
|
|
prospective_member_locations: &BTreeMap<String, String>,
|
|
subject_id: &str,
|
|
location_ids: &[String],
|
|
) -> Result<u8, KernelError> {
|
|
let (origin, destination) = if let Some(actor) = campaign.actors.get(subject_id) {
|
|
(
|
|
actor.location_id.as_str(),
|
|
prospective_actor_locations
|
|
.get(subject_id)
|
|
.map(String::as_str),
|
|
)
|
|
} else if let Some(gestalt) = campaign.gestalts.get(subject_id) {
|
|
(
|
|
gestalt.home_location_id.as_str(),
|
|
prospective_gestalt_locations
|
|
.get(subject_id)
|
|
.map(String::as_str),
|
|
)
|
|
} else if let Some(member_id) = subject_id.strip_prefix("member:") {
|
|
let origin = crate::resolution::dormant_member_location(campaign, member_id)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
return Ok(relative_activity_phase(
|
|
&origin,
|
|
prospective_member_locations
|
|
.get(member_id)
|
|
.map(String::as_str),
|
|
location_ids,
|
|
));
|
|
} else {
|
|
return Ok(1);
|
|
};
|
|
Ok(relative_activity_phase(origin, destination, location_ids))
|
|
}
|
|
|
|
fn relative_activity_phase(origin: &str, destination: Option<&str>, location_ids: &[String]) -> u8 {
|
|
let Some(destination) = destination.filter(|destination| *destination != origin) else {
|
|
return 1;
|
|
};
|
|
if location_ids.is_empty() || location_ids.iter().all(|location| location == origin) {
|
|
0
|
|
} else if location_ids.iter().all(|location| location == destination) {
|
|
2
|
|
} else {
|
|
1
|
|
}
|
|
}
|
|
|
|
fn apply_strategic_tick_plan(
|
|
campaign: &mut Campaign,
|
|
plan: crate::domain::StrategicTickPlan,
|
|
) -> Result<AppliedStrategicTickPlan, KernelError> {
|
|
let plan = if plan.selected_actions.is_empty() {
|
|
plan
|
|
} else {
|
|
let activity_outcomes = plan.activity_outcomes;
|
|
let mut projected =
|
|
crate::resolution::project_selected_actions(campaign, plan.selected_actions)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
projected.activity_outcomes = activity_outcomes;
|
|
projected
|
|
};
|
|
crate::outcome::validate_plan_activity_outcomes(campaign, &plan)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
let canonical_composition = !plan.selected_actions.is_empty();
|
|
let activity_means = plan
|
|
.selected_actions
|
|
.iter()
|
|
.map(|action| {
|
|
crate::resolution::cell_action_digest(action)
|
|
.map(|digest| (digest, action.intended_effect.clone()))
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))
|
|
})
|
|
.collect::<Result<BTreeMap<_, _>, _>>()?;
|
|
let prospective_actor_locations = plan
|
|
.actor_moves
|
|
.iter()
|
|
.map(|action| (action.actor_id.clone(), action.destination_id.clone()))
|
|
.collect::<BTreeMap<_, _>>();
|
|
let prospective_gestalt_locations = plan
|
|
.gestalt_migrations
|
|
.iter()
|
|
.map(|action| {
|
|
(
|
|
action.gestalt_id.clone(),
|
|
action.destination_location_id.clone(),
|
|
)
|
|
})
|
|
.collect::<BTreeMap<_, _>>();
|
|
let prospective_member_locations = plan
|
|
.member_migrations
|
|
.iter()
|
|
.map(|action| {
|
|
(
|
|
action.member_id.clone(),
|
|
action.destination_location_id.clone(),
|
|
)
|
|
})
|
|
.collect::<BTreeMap<_, _>>();
|
|
let lowering_plan = plan.clone();
|
|
let activity_outcomes = plan.activity_outcomes.clone();
|
|
let mut outcome_event_context: BTreeMap<String, (String, Vec<String>, Vec<String>)> =
|
|
BTreeMap::new();
|
|
for activity in &plan.gestalt_activities {
|
|
merge_strategic_outcome_event_context(
|
|
&mut outcome_event_context,
|
|
&activity.action_digest,
|
|
&activity.gestalt_id,
|
|
&activity.location_ids,
|
|
&activity.public_channels,
|
|
)?;
|
|
}
|
|
for activity in &plan.actor_activities {
|
|
merge_strategic_outcome_event_context(
|
|
&mut outcome_event_context,
|
|
&activity.action_digest,
|
|
&activity.actor_id,
|
|
&activity.location_ids,
|
|
&activity.public_channels,
|
|
)?;
|
|
}
|
|
for activity in &plan.member_activities {
|
|
merge_strategic_outcome_event_context(
|
|
&mut outcome_event_context,
|
|
&activity.action_digest,
|
|
&crate::domain::gestalt_member_subject_id(&activity.member_id),
|
|
&activity.location_ids,
|
|
&activity.public_channels,
|
|
)?;
|
|
}
|
|
// Every action in a strategic wave was chosen against the same committed
|
|
// snapshot. Keep that snapshot immutable while applying to a private copy
|
|
// so action ordering cannot rewrite another action's permissions and an
|
|
// invalid late action cannot leave this primitive partially mutated.
|
|
let mut next = campaign.clone();
|
|
let revision = campaign.revision + 1;
|
|
let at = campaign.world_time + Duration::hours(i64::from(campaign.tick_hours));
|
|
let mut events = Vec::new();
|
|
let mut event_phases = BTreeMap::new();
|
|
let mut seen_institutions = BTreeSet::new();
|
|
for action in plan.institution_actions {
|
|
if !seen_institutions.insert(action.institution_id.clone()) {
|
|
return Err(KernelError::Invalid(
|
|
"institution acts twice in one strategic tick".into(),
|
|
));
|
|
}
|
|
if action.posture.trim().is_empty() {
|
|
return Err(KernelError::Invalid(
|
|
"strategic institution posture is empty".into(),
|
|
));
|
|
}
|
|
if action.posture.chars().count() > MAX_POSTURE_CHARS {
|
|
return Err(KernelError::Invalid(format!(
|
|
"strategic institution posture exceeds {MAX_POSTURE_CHARS} characters"
|
|
)));
|
|
}
|
|
if action
|
|
.location_ids
|
|
.iter()
|
|
.any(|id| !campaign.locations.contains_key(id))
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"strategic institution action invented a location".into(),
|
|
));
|
|
}
|
|
validate_public_channels(&action.public_channels)?;
|
|
let institution = campaign
|
|
.institutions
|
|
.get(&action.institution_id)
|
|
.ok_or_else(|| KernelError::Invalid("strategic plan invented an institution".into()))?;
|
|
if !crate::resolution::substantive_text_change(&institution.posture, &action.posture) {
|
|
return Err(KernelError::Invalid(
|
|
"strategic institution action would not change its posture".into(),
|
|
));
|
|
}
|
|
let summary = format!(
|
|
"{} announces a new course: {}",
|
|
institution.name, action.posture
|
|
);
|
|
events.push(crate::domain::Event {
|
|
id: format!("strategic:{revision}:institution:{}", institution.id),
|
|
at,
|
|
kind: "institution_action".into(),
|
|
summary,
|
|
actor_ids: vec![],
|
|
institution_ids: vec![institution.id.clone()],
|
|
gestalt_ids: vec![],
|
|
location_ids: action.location_ids,
|
|
public_channels: action.public_channels,
|
|
});
|
|
}
|
|
|
|
let mut legacy_seen_gestalts = BTreeSet::new();
|
|
let mut seen_gestalt_pressures = BTreeSet::new();
|
|
for action in plan.gestalt_actions {
|
|
if !seen_gestalt_pressures.insert(action.gestalt_id.clone())
|
|
|| (!canonical_composition && !legacy_seen_gestalts.insert(action.gestalt_id.clone()))
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"gestalt acts twice in one strategic tick".into(),
|
|
));
|
|
}
|
|
validate_public_channels(&action.public_channels)?;
|
|
let gestalt = campaign
|
|
.gestalts
|
|
.get(&action.gestalt_id)
|
|
.ok_or_else(|| KernelError::Invalid("strategic plan invented a gestalt".into()))?;
|
|
crate::resolution::validate_gestalt_pressure_transition(
|
|
&gestalt.pressures,
|
|
&action.pressure_additions,
|
|
&action.pressure_resolutions,
|
|
)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
let mut summary_parts = Vec::new();
|
|
if !action.pressure_resolutions.is_empty() {
|
|
summary_parts.push(format!(
|
|
"A declaration from {} marks this matter settled: {}",
|
|
gestalt.name,
|
|
action.pressure_resolutions.join("; ")
|
|
));
|
|
}
|
|
if !action.pressure_additions.is_empty() {
|
|
summary_parts.push(format!(
|
|
"New public demand from {}: {}",
|
|
gestalt.name,
|
|
action.pressure_additions.join("; ")
|
|
));
|
|
}
|
|
events.push(crate::domain::Event {
|
|
id: format!("strategic:{revision}:gestalt:{}", gestalt.id),
|
|
at,
|
|
kind: "gestalt_action".into(),
|
|
summary: summary_parts.join("; "),
|
|
actor_ids: vec![],
|
|
institution_ids: vec![],
|
|
gestalt_ids: vec![gestalt.id.clone()],
|
|
location_ids: vec![gestalt.home_location_id.clone()],
|
|
public_channels: action.public_channels,
|
|
});
|
|
}
|
|
|
|
let mut seen_gestalt_migrations = BTreeSet::new();
|
|
for action in &plan.gestalt_migrations {
|
|
if !seen_gestalt_migrations.insert(action.gestalt_id.clone())
|
|
|| (!canonical_composition && !legacy_seen_gestalts.insert(action.gestalt_id.clone()))
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"gestalt acts twice in one strategic tick".into(),
|
|
));
|
|
}
|
|
validate_public_channels(&action.public_channels)?;
|
|
crate::resolution::validate_gestalt_migration(
|
|
campaign,
|
|
&action.gestalt_id,
|
|
&action.destination_gestalt_id,
|
|
&action.destination_location_id,
|
|
)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
}
|
|
for action in plan.gestalt_migrations {
|
|
let origin = campaign.gestalts[&action.gestalt_id]
|
|
.home_location_id
|
|
.clone();
|
|
let origin_name = campaign
|
|
.locations
|
|
.get(&origin)
|
|
.ok_or_else(|| KernelError::Invalid("gestalt migration origin is missing".into()))?
|
|
.name
|
|
.clone();
|
|
let gestalt_name = campaign.gestalts[&action.gestalt_id].name.clone();
|
|
let destination_location_name = campaign
|
|
.locations
|
|
.get(&action.destination_location_id)
|
|
.ok_or_else(|| KernelError::Invalid("gestalt migration destination is missing".into()))?
|
|
.name
|
|
.clone();
|
|
let destination_name = campaign.gestalts[&action.destination_gestalt_id]
|
|
.name
|
|
.clone();
|
|
events.push(crate::domain::Event {
|
|
id: format!(
|
|
"strategic:{revision}:gestalt-migration:{}",
|
|
action.gestalt_id
|
|
),
|
|
at,
|
|
kind: "gestalt_migration".into(),
|
|
summary: format!(
|
|
"{gestalt_name} relocates from {origin_name} to {destination_location_name} near {destination_name}."
|
|
),
|
|
actor_ids: vec![],
|
|
institution_ids: vec![],
|
|
gestalt_ids: vec![action.gestalt_id, action.destination_gestalt_id],
|
|
location_ids: vec![origin, action.destination_location_id],
|
|
public_channels: action.public_channels,
|
|
});
|
|
}
|
|
|
|
let mut seen_gestalt_activities = BTreeSet::new();
|
|
for action in plan.gestalt_activities {
|
|
let gestalt = campaign
|
|
.gestalts
|
|
.get(&action.gestalt_id)
|
|
.ok_or_else(|| KernelError::Invalid("strategic plan invented a gestalt".into()))?;
|
|
let locations = if action.location_ids.is_empty() {
|
|
vec![gestalt.home_location_id.clone()]
|
|
} else {
|
|
action.location_ids.clone()
|
|
};
|
|
if !seen_gestalt_activities.insert((
|
|
action.gestalt_id.clone(),
|
|
strategic_activity_scope_key(&action.activity, &action.target_subject_ids, &locations),
|
|
)) || (!canonical_composition && !legacy_seen_gestalts.insert(action.gestalt_id.clone()))
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"gestalt acts twice in one strategic tick".into(),
|
|
));
|
|
}
|
|
validate_public_channels(&action.public_channels)?;
|
|
let profile = campaign
|
|
.agency_profiles
|
|
.get(&action.gestalt_id)
|
|
.ok_or_else(|| KernelError::Invalid("strategic gestalt lacks agency scope".into()))?;
|
|
let allowed_targets =
|
|
crate::resolution::strategic_activity_targets(campaign, &action.gestalt_id);
|
|
let unique_targets = action.target_subject_ids.iter().collect::<BTreeSet<_>>();
|
|
let unique_locations = action.location_ids.iter().collect::<BTreeSet<_>>();
|
|
let needs_target = action.activity.requires_explicit_target_for_gestalt();
|
|
if action.target_subject_ids.len() > 4
|
|
|| unique_targets.len() != action.target_subject_ids.len()
|
|
|| action
|
|
.target_subject_ids
|
|
.iter()
|
|
.any(|target| !allowed_targets.contains(target))
|
|
|| (needs_target && action.target_subject_ids.is_empty())
|
|
|| action.location_ids.len() > 4
|
|
|| unique_locations.len() != action.location_ids.len()
|
|
|| action.location_ids.iter().any(|location| {
|
|
!profile.location_ids.contains(location)
|
|
&& prospective_gestalt_locations.get(&action.gestalt_id) != Some(location)
|
|
})
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"strategic gestalt activity exceeds exact graph or location scope".into(),
|
|
));
|
|
}
|
|
let target_names = action
|
|
.target_subject_ids
|
|
.iter()
|
|
.map(|target| agency_subject_name(campaign, target))
|
|
.collect::<Result<Vec<_>, _>>()?;
|
|
let institution_ids = action
|
|
.target_subject_ids
|
|
.iter()
|
|
.filter(|target| campaign.institutions.contains_key(*target))
|
|
.cloned()
|
|
.collect();
|
|
let actor_ids = action
|
|
.target_subject_ids
|
|
.iter()
|
|
.filter(|target| {
|
|
campaign.actors.contains_key(*target)
|
|
|| target
|
|
.strip_prefix("member:")
|
|
.is_some_and(|member_id| campaign.gestalt_members.contains_key(member_id))
|
|
})
|
|
.cloned()
|
|
.collect();
|
|
let mut gestalt_ids = vec![action.gestalt_id.clone()];
|
|
gestalt_ids.extend(
|
|
action
|
|
.target_subject_ids
|
|
.iter()
|
|
.filter(|target| campaign.gestalts.contains_key(*target))
|
|
.cloned(),
|
|
);
|
|
let phase = strategic_activity_phase(
|
|
campaign,
|
|
&prospective_actor_locations,
|
|
&prospective_gestalt_locations,
|
|
&prospective_member_locations,
|
|
&action.gestalt_id,
|
|
&locations,
|
|
)?;
|
|
let scope_digest = strategic_activity_scope_digest(
|
|
&action.activity,
|
|
&action.target_subject_ids,
|
|
&locations,
|
|
);
|
|
let event = crate::domain::Event {
|
|
id: format!(
|
|
"strategic:{revision}:gestalt-activity:{}:{}:{scope_digest}",
|
|
action.gestalt_id,
|
|
strategic_activity_id(&action.activity),
|
|
),
|
|
at,
|
|
kind: "gestalt_activity".into(),
|
|
summary: strategic_activity_summary(
|
|
&gestalt.name,
|
|
&action.activity,
|
|
&target_names,
|
|
activity_means
|
|
.get(&action.action_digest)
|
|
.map(String::as_str),
|
|
),
|
|
actor_ids,
|
|
institution_ids,
|
|
gestalt_ids,
|
|
location_ids: locations,
|
|
public_channels: action.public_channels,
|
|
};
|
|
event_phases.insert(event.id.clone(), phase);
|
|
events.push(event);
|
|
}
|
|
|
|
let mut legacy_seen_actors = BTreeSet::new();
|
|
let mut seen_actor_moves = BTreeSet::new();
|
|
for action in plan.actor_moves {
|
|
if !seen_actor_moves.insert(action.actor_id.clone())
|
|
|| (!canonical_composition && !legacy_seen_actors.insert(action.actor_id.clone()))
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"actor moves twice in one strategic tick".into(),
|
|
));
|
|
}
|
|
if is_human_controlled_actor(campaign, &action.actor_id) {
|
|
return Err(KernelError::Invalid(
|
|
"strategic simulation cannot puppet a human-controlled actor".into(),
|
|
));
|
|
}
|
|
validate_public_channels(&action.public_channels)?;
|
|
let actor = campaign
|
|
.actors
|
|
.get(&action.actor_id)
|
|
.ok_or_else(|| KernelError::Invalid("strategic plan invented an actor".into()))?;
|
|
let route = campaign
|
|
.locations
|
|
.get(&actor.location_id)
|
|
.and_then(|location| {
|
|
location
|
|
.routes
|
|
.values()
|
|
.find(|route| route.destination_id == action.destination_id)
|
|
})
|
|
.ok_or_else(|| {
|
|
KernelError::Invalid("strategic actor movement has no direct route".into())
|
|
})?;
|
|
if route.travel_minutes > campaign.tick_hours.saturating_mul(60) {
|
|
return Err(KernelError::Invalid(
|
|
"strategic actor movement exceeds the tick duration".into(),
|
|
));
|
|
}
|
|
let origin = actor.location_id.clone();
|
|
let actor_name = actor.name.clone();
|
|
let origin_name = campaign
|
|
.locations
|
|
.get(&origin)
|
|
.ok_or_else(|| KernelError::Invalid("actor movement origin is missing".into()))?
|
|
.name
|
|
.clone();
|
|
let destination_name = campaign
|
|
.locations
|
|
.get(&action.destination_id)
|
|
.ok_or_else(|| KernelError::Invalid("actor movement destination is missing".into()))?
|
|
.name
|
|
.clone();
|
|
events.push(crate::domain::Event {
|
|
id: format!("strategic:{revision}:actor:{}", action.actor_id),
|
|
at,
|
|
kind: "actor_movement".into(),
|
|
summary: format!("{actor_name} moves from {origin_name} to {destination_name}."),
|
|
actor_ids: vec![action.actor_id],
|
|
institution_ids: vec![],
|
|
gestalt_ids: vec![],
|
|
location_ids: vec![origin, action.destination_id],
|
|
public_channels: action.public_channels,
|
|
});
|
|
}
|
|
|
|
let mut seen_actor_activities = BTreeSet::new();
|
|
for action in plan.actor_activities {
|
|
if !seen_actor_activities.insert((
|
|
action.actor_id.clone(),
|
|
strategic_activity_scope_key(
|
|
&action.activity,
|
|
&action.target_subject_ids,
|
|
&action.location_ids,
|
|
),
|
|
)) || (!canonical_composition && !legacy_seen_actors.insert(action.actor_id.clone()))
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"actor acts twice in one strategic tick".into(),
|
|
));
|
|
}
|
|
if is_human_controlled_actor(campaign, &action.actor_id) {
|
|
return Err(KernelError::Invalid(
|
|
"strategic simulation cannot puppet a human-controlled actor".into(),
|
|
));
|
|
}
|
|
validate_public_channels(&action.public_channels)?;
|
|
let actor = campaign
|
|
.actors
|
|
.get(&action.actor_id)
|
|
.ok_or_else(|| KernelError::Invalid("strategic plan invented an actor".into()))?;
|
|
let allowed_targets =
|
|
crate::resolution::strategic_activity_targets(campaign, &action.actor_id);
|
|
let unique_targets = action.target_subject_ids.iter().collect::<BTreeSet<_>>();
|
|
let needs_target = !action.activity.allows_targetless_local_attempt();
|
|
if action.target_subject_ids.len() > 4
|
|
|| unique_targets.len() != action.target_subject_ids.len()
|
|
|| action
|
|
.target_subject_ids
|
|
.iter()
|
|
.any(|target| !allowed_targets.contains(target))
|
|
|| (needs_target && action.target_subject_ids.is_empty())
|
|
|| action.location_ids.len() != 1
|
|
|| (action.location_ids[0] != actor.location_id
|
|
&& prospective_actor_locations.get(&action.actor_id) != action.location_ids.first())
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"strategic actor activity exceeds exact graph or location scope".into(),
|
|
));
|
|
}
|
|
let target_names = action
|
|
.target_subject_ids
|
|
.iter()
|
|
.map(|target| agency_subject_name(campaign, target))
|
|
.collect::<Result<Vec<_>, _>>()?;
|
|
let institution_ids = action
|
|
.target_subject_ids
|
|
.iter()
|
|
.filter(|target| campaign.institutions.contains_key(*target))
|
|
.cloned()
|
|
.collect();
|
|
let mut actor_ids = vec![action.actor_id.clone()];
|
|
actor_ids.extend(
|
|
action
|
|
.target_subject_ids
|
|
.iter()
|
|
.filter(|target| {
|
|
campaign.actors.contains_key(*target)
|
|
|| target.strip_prefix("member:").is_some_and(|member_id| {
|
|
campaign.gestalt_members.contains_key(member_id)
|
|
})
|
|
})
|
|
.cloned(),
|
|
);
|
|
actor_ids.sort();
|
|
actor_ids.dedup();
|
|
let mut gestalt_ids = action
|
|
.target_subject_ids
|
|
.iter()
|
|
.filter(|target| campaign.gestalts.contains_key(*target))
|
|
.cloned()
|
|
.collect::<Vec<_>>();
|
|
gestalt_ids.sort();
|
|
gestalt_ids.dedup();
|
|
let phase = strategic_activity_phase(
|
|
campaign,
|
|
&prospective_actor_locations,
|
|
&prospective_gestalt_locations,
|
|
&prospective_member_locations,
|
|
&action.actor_id,
|
|
&action.location_ids,
|
|
)?;
|
|
let scope_digest = strategic_activity_scope_digest(
|
|
&action.activity,
|
|
&action.target_subject_ids,
|
|
&action.location_ids,
|
|
);
|
|
let event = Event {
|
|
id: format!(
|
|
"strategic:{revision}:actor-activity:{}:{}:{scope_digest}",
|
|
action.actor_id,
|
|
strategic_activity_id(&action.activity),
|
|
),
|
|
at,
|
|
kind: "actor_activity".into(),
|
|
summary: strategic_activity_summary(
|
|
&actor.name,
|
|
&action.activity,
|
|
&target_names,
|
|
activity_means
|
|
.get(&action.action_digest)
|
|
.map(String::as_str),
|
|
),
|
|
actor_ids,
|
|
institution_ids,
|
|
gestalt_ids,
|
|
location_ids: action.location_ids,
|
|
public_channels: action.public_channels,
|
|
};
|
|
event_phases.insert(event.id.clone(), phase);
|
|
events.push(event);
|
|
}
|
|
|
|
let mut legacy_seen_members = BTreeSet::new();
|
|
let mut seen_member_activities = BTreeSet::new();
|
|
for action in plan.member_activities {
|
|
if !seen_member_activities.insert((
|
|
action.member_id.clone(),
|
|
strategic_activity_scope_key(
|
|
&action.activity,
|
|
&action.target_subject_ids,
|
|
&action.location_ids,
|
|
),
|
|
)) || (!canonical_composition && !legacy_seen_members.insert(action.member_id.clone()))
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"gestalt member acts twice in one strategic tick".into(),
|
|
));
|
|
}
|
|
validate_public_channels(&action.public_channels)?;
|
|
let member = campaign
|
|
.gestalt_members
|
|
.get(&action.member_id)
|
|
.filter(|member| {
|
|
member.materialized_actor_id.is_none()
|
|
&& member.gestalt_id == action.source_gestalt_id
|
|
})
|
|
.ok_or_else(|| {
|
|
KernelError::Invalid("strategic member activity has stale identity scope".into())
|
|
})?;
|
|
let allowed_targets =
|
|
crate::resolution::member_activity_targets(campaign, &action.member_id)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
let exact_location =
|
|
crate::resolution::dormant_member_location(campaign, &action.member_id)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
let unique_targets = action.target_subject_ids.iter().collect::<BTreeSet<_>>();
|
|
let needs_target = !action.activity.allows_targetless_local_attempt();
|
|
if action.target_subject_ids.len() > 4
|
|
|| unique_targets.len() != action.target_subject_ids.len()
|
|
|| action
|
|
.target_subject_ids
|
|
.iter()
|
|
.any(|target| !allowed_targets.contains(target))
|
|
|| (needs_target && action.target_subject_ids.is_empty())
|
|
|| action.location_ids.len() != 1
|
|
|| (action.location_ids[0] != exact_location
|
|
&& prospective_member_locations.get(&action.member_id)
|
|
!= action.location_ids.first())
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"strategic member activity exceeds exact graph or location scope".into(),
|
|
));
|
|
}
|
|
let target_names = action
|
|
.target_subject_ids
|
|
.iter()
|
|
.map(|target| agency_subject_name(campaign, target))
|
|
.collect::<Result<Vec<_>, _>>()?;
|
|
let institution_ids = action
|
|
.target_subject_ids
|
|
.iter()
|
|
.filter(|target| campaign.institutions.contains_key(*target))
|
|
.cloned()
|
|
.collect();
|
|
let mut actor_ids = vec![crate::domain::gestalt_member_subject_id(&action.member_id)];
|
|
actor_ids.extend(
|
|
action
|
|
.target_subject_ids
|
|
.iter()
|
|
.filter(|target| {
|
|
campaign.actors.contains_key(*target)
|
|
|| target.strip_prefix("member:").is_some_and(|member_id| {
|
|
campaign.gestalt_members.contains_key(member_id)
|
|
})
|
|
})
|
|
.cloned(),
|
|
);
|
|
actor_ids.sort();
|
|
actor_ids.dedup();
|
|
let mut gestalt_ids = vec![action.source_gestalt_id.clone()];
|
|
gestalt_ids.extend(
|
|
action
|
|
.target_subject_ids
|
|
.iter()
|
|
.filter(|target| campaign.gestalts.contains_key(*target))
|
|
.cloned(),
|
|
);
|
|
gestalt_ids.sort();
|
|
gestalt_ids.dedup();
|
|
let phase = strategic_activity_phase(
|
|
campaign,
|
|
&prospective_actor_locations,
|
|
&prospective_gestalt_locations,
|
|
&prospective_member_locations,
|
|
&crate::domain::gestalt_member_subject_id(&action.member_id),
|
|
&action.location_ids,
|
|
)?;
|
|
let scope_digest = strategic_activity_scope_digest(
|
|
&action.activity,
|
|
&action.target_subject_ids,
|
|
&action.location_ids,
|
|
);
|
|
let event = Event {
|
|
id: format!(
|
|
"strategic:{revision}:member-activity:{}:{}:{scope_digest}",
|
|
action.member_id,
|
|
strategic_activity_id(&action.activity),
|
|
),
|
|
at,
|
|
kind: "gestalt_member_activity".into(),
|
|
summary: strategic_activity_summary(
|
|
&member.name,
|
|
&action.activity,
|
|
&target_names,
|
|
activity_means
|
|
.get(&action.action_digest)
|
|
.map(String::as_str),
|
|
),
|
|
actor_ids,
|
|
institution_ids,
|
|
gestalt_ids,
|
|
location_ids: action.location_ids,
|
|
public_channels: action.public_channels,
|
|
};
|
|
event_phases.insert(event.id.clone(), phase);
|
|
events.push(event);
|
|
}
|
|
let mut seen_member_migrations = BTreeSet::new();
|
|
for action in plan.member_migrations {
|
|
if !seen_member_migrations.insert(action.member_id.clone())
|
|
|| (!canonical_composition && !legacy_seen_members.insert(action.member_id.clone()))
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"gestalt member migrates twice in one strategic tick".into(),
|
|
));
|
|
}
|
|
validate_public_channels(&action.public_channels)?;
|
|
crate::resolution::validate_member_migration(
|
|
campaign,
|
|
&action.member_id,
|
|
&action.source_gestalt_id,
|
|
&action.destination_gestalt_id,
|
|
&action.destination_location_id,
|
|
)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
let origin = campaign.gestalt_members[&action.member_id]
|
|
.last_location_id
|
|
.clone()
|
|
.unwrap_or_else(|| {
|
|
campaign.gestalts[&action.source_gestalt_id]
|
|
.home_location_id
|
|
.clone()
|
|
});
|
|
let member_name = campaign.gestalt_members[&action.member_id].name.clone();
|
|
let origin_name = campaign
|
|
.locations
|
|
.get(&origin)
|
|
.ok_or_else(|| KernelError::Invalid("member migration origin is missing".into()))?
|
|
.name
|
|
.clone();
|
|
let destination_location_name = campaign
|
|
.locations
|
|
.get(&action.destination_location_id)
|
|
.ok_or_else(|| KernelError::Invalid("member migration destination is missing".into()))?
|
|
.name
|
|
.clone();
|
|
let destination_gestalt_name = campaign.gestalts[&action.destination_gestalt_id]
|
|
.name
|
|
.clone();
|
|
events.push(crate::domain::Event {
|
|
id: format!("strategic:{revision}:member:{}", action.member_id),
|
|
at,
|
|
kind: "gestalt_member_migration".into(),
|
|
summary: format!(
|
|
"{member_name} moves from {origin_name} to {destination_location_name} and joins {destination_gestalt_name}."
|
|
),
|
|
actor_ids: vec![crate::domain::gestalt_member_subject_id(&action.member_id)],
|
|
institution_ids: vec![],
|
|
gestalt_ids: vec![action.source_gestalt_id, action.destination_gestalt_id],
|
|
location_ids: vec![origin, action.destination_location_id],
|
|
public_channels: action.public_channels,
|
|
});
|
|
}
|
|
let plan_digest = crate::legacy_transition::digest_serializable(&lowering_plan)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
let mutation = crate::legacy_transition::lower_strategic_wave(
|
|
campaign,
|
|
&lowering_plan,
|
|
&format!("strategic-wave:{plan_digest}"),
|
|
Utc::now() + Duration::minutes(5),
|
|
)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?
|
|
.map(|transition| {
|
|
let receipt =
|
|
crate::legacy_transition::apply_lowered_transition(&mut next, &transition, Utc::now())
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
Ok::<_, KernelError>((transition, receipt))
|
|
})
|
|
.transpose()?;
|
|
for outcome in activity_outcomes {
|
|
let (source_subject_id, locations, public_channels) = outcome_event_context
|
|
.remove(&outcome.action_digest)
|
|
.ok_or_else(|| {
|
|
KernelError::Invalid("strategic outcome lost its activity context".into())
|
|
})?;
|
|
if matches!(
|
|
&outcome.effect,
|
|
crate::domain::StrategicOutcomeEffect::NoMaterialChange { .. }
|
|
) {
|
|
continue;
|
|
}
|
|
let mut subject_ids = BTreeSet::from([source_subject_id.clone()]);
|
|
collect_outcome_subject_ids(&outcome.effect, &mut subject_ids);
|
|
let mut actor_ids = Vec::new();
|
|
let mut institution_ids = Vec::new();
|
|
let mut gestalt_ids = Vec::new();
|
|
for subject_id in subject_ids {
|
|
if let Some(member_id) = subject_id.strip_prefix("member:") {
|
|
actor_ids.push(subject_id.clone());
|
|
if let Some(member) = next.gestalt_members.get(member_id) {
|
|
gestalt_ids.push(member.gestalt_id.clone());
|
|
}
|
|
} else if next.actors.contains_key(&subject_id) {
|
|
actor_ids.push(subject_id);
|
|
} else if next.institutions.contains_key(&subject_id) {
|
|
institution_ids.push(subject_id);
|
|
} else if next.gestalts.contains_key(&subject_id) {
|
|
gestalt_ids.push(subject_id);
|
|
}
|
|
}
|
|
actor_ids.sort();
|
|
actor_ids.dedup();
|
|
institution_ids.sort();
|
|
institution_ids.dedup();
|
|
gestalt_ids.sort();
|
|
gestalt_ids.dedup();
|
|
let digest_suffix = outcome
|
|
.action_digest
|
|
.strip_prefix("sha256:")
|
|
.unwrap_or(&outcome.action_digest)
|
|
.chars()
|
|
.take(16)
|
|
.collect::<String>();
|
|
let phase = strategic_activity_phase(
|
|
campaign,
|
|
&prospective_actor_locations,
|
|
&prospective_gestalt_locations,
|
|
&prospective_member_locations,
|
|
&source_subject_id,
|
|
&locations,
|
|
)?;
|
|
let event = Event {
|
|
id: format!("strategic:{revision}:activity-outcome:{digest_suffix}"),
|
|
at,
|
|
kind: "strategic_activity_outcome".into(),
|
|
summary: outcome.summary,
|
|
actor_ids,
|
|
institution_ids,
|
|
gestalt_ids,
|
|
location_ids: locations,
|
|
public_channels,
|
|
};
|
|
event_phases.insert(event.id.clone(), phase);
|
|
events.push(event);
|
|
}
|
|
events.sort_by_key(|event| event_phases.get(&event.id).copied().unwrap_or(1));
|
|
*campaign = next;
|
|
Ok(AppliedStrategicTickPlan { events, mutation })
|
|
}
|
|
|
|
fn collect_outcome_subject_ids(
|
|
effect: &crate::domain::StrategicOutcomeEffect,
|
|
subjects: &mut BTreeSet<String>,
|
|
) {
|
|
use crate::domain::StrategicOutcomeEffect;
|
|
match effect {
|
|
StrategicOutcomeEffect::NoMaterialChange { .. } => {}
|
|
StrategicOutcomeEffect::ResourceCreated {
|
|
owner_subject_id, ..
|
|
}
|
|
| StrategicOutcomeEffect::ResourceConsumed {
|
|
owner_subject_id, ..
|
|
}
|
|
| StrategicOutcomeEffect::KnowledgeLearned {
|
|
owner_subject_id, ..
|
|
} => {
|
|
subjects.insert(owner_subject_id.clone());
|
|
}
|
|
StrategicOutcomeEffect::ResourceTransferred {
|
|
from_subject_id,
|
|
to_subject_id,
|
|
..
|
|
} => {
|
|
subjects.insert(from_subject_id.clone());
|
|
subjects.insert(to_subject_id.clone());
|
|
}
|
|
StrategicOutcomeEffect::KnowledgeCommunicated {
|
|
from_subject_id,
|
|
to_subject_ids,
|
|
..
|
|
} => {
|
|
subjects.insert(from_subject_id.clone());
|
|
subjects.extend(to_subject_ids.iter().cloned());
|
|
}
|
|
StrategicOutcomeEffect::GestaltPressure { gestalt_id, .. } => {
|
|
subjects.insert(gestalt_id.clone());
|
|
}
|
|
StrategicOutcomeEffect::AgencyRelationShift { .. } => {}
|
|
StrategicOutcomeEffect::MemberMemory { member_id, .. }
|
|
| StrategicOutcomeEffect::MemberObligation { member_id, .. }
|
|
| StrategicOutcomeEffect::MemberRelationship { member_id, .. } => {
|
|
subjects.insert(crate::domain::gestalt_member_subject_id(member_id));
|
|
if let StrategicOutcomeEffect::MemberRelationship {
|
|
other_subject_id, ..
|
|
} = effect
|
|
{
|
|
subjects.insert(other_subject_id.clone());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn strategic_activity_summary(
|
|
source_name: &str,
|
|
activity: &StrategicActivityKind,
|
|
target_names: &[String],
|
|
admitted_means: Option<&str>,
|
|
) -> String {
|
|
if let Some(means) = admitted_means
|
|
.map(str::trim)
|
|
.filter(|means| !means.is_empty())
|
|
{
|
|
let means = means.trim_end_matches(['.', '!', '?']);
|
|
let mut characters = means.chars();
|
|
let lowered = characters
|
|
.next()
|
|
.map(|first| first.to_lowercase().chain(characters).collect::<String>())
|
|
.unwrap_or_default();
|
|
if let Some(rest) = lowered.strip_prefix("attempt to ") {
|
|
return format!("{source_name} attempts to {rest}.");
|
|
}
|
|
if let Some(rest) = lowered.strip_prefix("attempt ") {
|
|
return format!("{source_name} attempts {rest}.");
|
|
}
|
|
return format!("{source_name} attempts to {lowered}.");
|
|
}
|
|
let targets = target_names.join(", ");
|
|
match (activity, target_names.is_empty()) {
|
|
(StrategicActivityKind::Prepare, true) => {
|
|
format!("{source_name} undertakes preparations.")
|
|
}
|
|
(StrategicActivityKind::Prepare, false) => {
|
|
format!("{source_name} undertakes preparations concerning {targets}.")
|
|
}
|
|
(StrategicActivityKind::Coordinate, false) => {
|
|
format!("{source_name} attempts to coordinate with {targets}.")
|
|
}
|
|
(StrategicActivityKind::Coordinate, true) => {
|
|
format!("{source_name} attempts internal coordination.")
|
|
}
|
|
(StrategicActivityKind::Investigate, true) => {
|
|
format!("{source_name} begins a local investigation.")
|
|
}
|
|
(StrategicActivityKind::Investigate, false) => {
|
|
format!("{source_name} begins investigating {targets}.")
|
|
}
|
|
(StrategicActivityKind::Recruit, false) => {
|
|
format!("{source_name} attempts recruitment involving {targets}.")
|
|
}
|
|
(StrategicActivityKind::Obstruct, false) => {
|
|
format!("{source_name} attempts to obstruct {targets}.")
|
|
}
|
|
(StrategicActivityKind::Obstruct, true) => {
|
|
format!("{source_name} attempts local interference.")
|
|
}
|
|
(StrategicActivityKind::Trade, false) => {
|
|
format!("{source_name} offers a trade to {targets}.")
|
|
}
|
|
(StrategicActivityKind::Communicate, true) => {
|
|
format!("{source_name} attempts a local communication.")
|
|
}
|
|
(StrategicActivityKind::Communicate, false) => {
|
|
format!("{source_name} sends a communication to {targets}.")
|
|
}
|
|
_ => unreachable!("validated strategic activity requires a target"),
|
|
}
|
|
}
|
|
|
|
fn strategic_activity_id(activity: &StrategicActivityKind) -> &'static str {
|
|
match activity {
|
|
StrategicActivityKind::Prepare => "prepare",
|
|
StrategicActivityKind::Coordinate => "coordinate",
|
|
StrategicActivityKind::Investigate => "investigate",
|
|
StrategicActivityKind::Recruit => "recruit",
|
|
StrategicActivityKind::Obstruct => "obstruct",
|
|
StrategicActivityKind::Trade => "trade",
|
|
StrategicActivityKind::Communicate => "communicate",
|
|
}
|
|
}
|
|
|
|
fn strategic_activity_scope_key(
|
|
activity: &StrategicActivityKind,
|
|
target_subject_ids: &[String],
|
|
location_ids: &[String],
|
|
) -> (&'static str, Vec<String>, Vec<String>) {
|
|
let mut targets = target_subject_ids.to_vec();
|
|
let mut locations = location_ids.to_vec();
|
|
targets.sort();
|
|
locations.sort();
|
|
(strategic_activity_id(activity), targets, locations)
|
|
}
|
|
|
|
fn strategic_activity_scope_digest(
|
|
activity: &StrategicActivityKind,
|
|
target_subject_ids: &[String],
|
|
location_ids: &[String],
|
|
) -> String {
|
|
let scope = strategic_activity_scope_key(activity, target_subject_ids, location_ids);
|
|
let bytes = rmp_serde::to_vec_named(&scope)
|
|
.expect("serializing a strategic activity scope made only of strings cannot fail");
|
|
format!("{:x}", Sha256::digest(bytes))
|
|
}
|
|
|
|
fn agency_subject_name(campaign: &Campaign, subject_id: &str) -> Result<String, KernelError> {
|
|
campaign
|
|
.actors
|
|
.get(subject_id)
|
|
.map(|value| value.name.clone())
|
|
.or_else(|| {
|
|
campaign
|
|
.institutions
|
|
.get(subject_id)
|
|
.map(|value| value.name.clone())
|
|
})
|
|
.or_else(|| {
|
|
campaign
|
|
.gestalts
|
|
.get(subject_id)
|
|
.map(|value| value.name.clone())
|
|
})
|
|
.or_else(|| {
|
|
crate::resolution::dormant_member_id_for_subject(campaign, subject_id).and_then(
|
|
|member_id| {
|
|
campaign
|
|
.gestalt_members
|
|
.get(member_id)
|
|
.map(|value| value.name.clone())
|
|
},
|
|
)
|
|
})
|
|
.ok_or_else(|| KernelError::Invalid("strategic activity target vanished".into()))
|
|
}
|
|
|
|
fn deterministic_strategic_tick_plan() -> StrategicTickPlan {
|
|
// Deterministic time and clock obligations are lowered by the same wave
|
|
// transition. Without an admitted Persona wave there is no authority to
|
|
// invent actor or institution activity.
|
|
StrategicTickPlan::default()
|
|
}
|
|
|
|
fn validate_public_channels(channels: &[String]) -> Result<(), KernelError> {
|
|
if channels.len() > 8
|
|
|| channels
|
|
.iter()
|
|
.any(|channel| !crate::resolution::information_channel_is_concrete(channel))
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"strategic action has invalid information channels".into(),
|
|
));
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn valid_sha256(value: &str) -> bool {
|
|
value
|
|
.strip_prefix("sha256:")
|
|
.is_some_and(|digest| digest.len() == 64 && digest.bytes().all(|b| b.is_ascii_hexdigit()))
|
|
}
|
|
|
|
fn commit_gestalt_presence(
|
|
store: &CampaignStore,
|
|
row: cultcache_legacy::CultCacheEnvelope,
|
|
before: Campaign,
|
|
mut campaign: Campaign,
|
|
kind: &str,
|
|
reason: &str,
|
|
) -> Result<CommandResult, KernelError> {
|
|
let previous_resolution_epoch = campaign.resolution_policy.resolution_epoch;
|
|
crate::resolution::ensure_agency_profiles(&mut campaign);
|
|
let mut changes = Vec::new();
|
|
for (member_id, member) in &campaign.gestalt_members {
|
|
let previous_actor = before
|
|
.gestalt_members
|
|
.get(member_id)
|
|
.and_then(|value| value.materialized_actor_id.as_deref());
|
|
let current_actor = member.materialized_actor_id.as_deref();
|
|
if previous_actor == current_actor {
|
|
continue;
|
|
}
|
|
let (operation, actor_id) = match (previous_actor, current_actor) {
|
|
(None, Some(actor)) => ("materialized", actor),
|
|
(Some(actor), None) => ("dematerialized", actor),
|
|
(Some(_), Some(actor)) => ("rematerialized", actor),
|
|
(None, None) => unreachable!(),
|
|
};
|
|
let gestalt = campaign
|
|
.gestalts
|
|
.get(&member.gestalt_id)
|
|
.ok_or_else(|| KernelError::Invalid("gestalt receipt lost its baseline".into()))?;
|
|
changes.push(crate::domain::GestaltPresenceChange {
|
|
operation: operation.into(),
|
|
gestalt_id: member.gestalt_id.clone(),
|
|
member_id: member_id.clone(),
|
|
actor_id: actor_id.into(),
|
|
gestalt_version: gestalt.version,
|
|
member_version: member.version,
|
|
});
|
|
}
|
|
if changes.is_empty() {
|
|
return Err(KernelError::Invalid(
|
|
"gestalt presence command produced no presence change".into(),
|
|
));
|
|
}
|
|
let previous_revision = campaign.revision;
|
|
campaign.revision += 1;
|
|
campaign.resolution_policy.resolution_epoch = previous_resolution_epoch.saturating_add(1);
|
|
campaign.resolution_cover = None;
|
|
let committed_at = Utc::now();
|
|
let player_location = campaign.actors[&campaign.player_actor_id]
|
|
.location_id
|
|
.clone();
|
|
let visible_arrivals = changes
|
|
.iter()
|
|
.filter(|change| change.operation != "dematerialized")
|
|
.filter_map(|change| {
|
|
let actor = campaign.actors.get(&change.actor_id)?;
|
|
(actor.location_id == player_location).then(|| {
|
|
format!(
|
|
"{} is here with {} at {}.",
|
|
actor.name,
|
|
campaign.gestalts[&change.gestalt_id].name,
|
|
campaign.locations[&actor.location_id].name
|
|
)
|
|
})
|
|
})
|
|
.collect::<Vec<_>>();
|
|
campaign
|
|
.transcript
|
|
.extend(visible_arrivals.into_iter().map(|text| NarrativeTurn {
|
|
revision: campaign.revision,
|
|
at: committed_at,
|
|
speaker: "world".into(),
|
|
text,
|
|
persona_response_actor_ids: BTreeSet::new(),
|
|
}));
|
|
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,
|
|
roll: None,
|
|
};
|
|
let gestalt_receipt = crate::domain::GestaltMaterializationReceipt {
|
|
schema: "ghostlight.gestalt_materialization_receipt.v1".into(),
|
|
campaign_id: campaign.id,
|
|
previous_revision,
|
|
revision: campaign.revision,
|
|
previous_resolution_epoch,
|
|
resolution_epoch: campaign.resolution_policy.resolution_epoch,
|
|
reason: reason.into(),
|
|
changes,
|
|
committed_at,
|
|
};
|
|
let key = format!("{}-{}", campaign.id, campaign.revision);
|
|
store
|
|
.append_gestalt_presence(&row, &campaign, &key, &receipt, &gestalt_receipt)
|
|
.map_err(persist)?;
|
|
Ok(CommandResult::Committed { campaign, receipt })
|
|
}
|
|
|
|
fn commit_strategic_tick(
|
|
store: &CampaignStore,
|
|
row: cultcache_legacy::CultCacheEnvelope,
|
|
mut campaign: Campaign,
|
|
source: TickSource,
|
|
model_receipt_hash: Option<String>,
|
|
event_ids: Vec<String>,
|
|
resolution_wave: Option<ResolutionWaveCommit>,
|
|
mutation: Option<(
|
|
crate::legacy_transition::LoweredLegacyTransition,
|
|
crate::transition::WorldMutationReceipt,
|
|
)>,
|
|
) -> Result<CommandResult, KernelError> {
|
|
crate::resolution::ensure_agency_profiles(&mut campaign);
|
|
let previous_revision = campaign.revision;
|
|
campaign.revision += 1;
|
|
let committed_at = Utc::now();
|
|
let external_authorities = store
|
|
.load_all::<crate::consumer::ExternalSubjectAuthority>("external_subject_authority.v1")
|
|
.map_err(persist)?;
|
|
let external_proposals = resolution_wave
|
|
.as_ref()
|
|
.map(|wave| {
|
|
external_proposals_for_wave(
|
|
campaign.id,
|
|
campaign.revision,
|
|
committed_at,
|
|
wave,
|
|
&external_authorities,
|
|
)
|
|
})
|
|
.transpose()
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?
|
|
.unwrap_or_default();
|
|
let receipt = WorldCommitReceipt {
|
|
schema: "ghostlight.world_commit_receipt.v1".into(),
|
|
campaign_id: campaign.id,
|
|
previous_revision,
|
|
revision: campaign.revision,
|
|
command_kind: "strategic_tick".into(),
|
|
committed_at,
|
|
roll: None,
|
|
};
|
|
let strategic = crate::domain::StrategicTickReceipt {
|
|
schema: "ghostlight.strategic_tick.v1".into(),
|
|
campaign_id: campaign.id,
|
|
previous_revision,
|
|
revision: campaign.revision,
|
|
source,
|
|
model_receipt_hash,
|
|
model_receipt_hashes: resolution_wave
|
|
.as_ref()
|
|
.map(|wave| wave.model_receipt_hashes.clone())
|
|
.unwrap_or_default(),
|
|
resolution_epoch: resolution_wave.as_ref().map(|wave| wave.resolution_epoch),
|
|
resolution_cover_id: resolution_wave.as_ref().map(|wave| {
|
|
format!(
|
|
"{}:{}:{}",
|
|
campaign.id, wave.world_revision, wave.resolution_epoch
|
|
)
|
|
}),
|
|
event_ids,
|
|
committed_at,
|
|
};
|
|
let key = format!("{}-{}", campaign.id, campaign.revision);
|
|
store
|
|
.append_strategic_tick(
|
|
&row,
|
|
&campaign,
|
|
&key,
|
|
&receipt,
|
|
&strategic,
|
|
resolution_wave.as_ref(),
|
|
&external_proposals,
|
|
mutation
|
|
.as_ref()
|
|
.map(|(transition, receipt)| (&transition.authority, &transition.batch, receipt)),
|
|
)
|
|
.map_err(persist)?;
|
|
Ok(CommandResult::Committed { campaign, receipt })
|
|
}
|
|
|
|
fn external_proposals_for_wave(
|
|
campaign_id: uuid::Uuid,
|
|
world_revision: u64,
|
|
created_at: chrono::DateTime<Utc>,
|
|
wave: &ResolutionWaveCommit,
|
|
authorities: &[crate::consumer::ExternalSubjectAuthority],
|
|
) -> anyhow::Result<Vec<crate::consumer::ExternalWorldProposal>> {
|
|
let mut proposals = Vec::new();
|
|
for appraisal in &wave.appraisals {
|
|
for action in &appraisal.actions {
|
|
let action_digest = crate::resolution::cell_action_digest(action)?;
|
|
for authority in authorities {
|
|
if crate::consumer::proposal_targets(action)
|
|
.contains(&authority.subject_id.as_str())
|
|
{
|
|
let id = crate::legacy_transition::digest_serializable(&(
|
|
campaign_id,
|
|
world_revision,
|
|
&authority.id,
|
|
&action_digest,
|
|
))?;
|
|
proposals.push(crate::consumer::ExternalWorldProposal {
|
|
schema: "ghostlight.external_world_proposal.v1".into(),
|
|
id: format!("external-proposal:{id}"),
|
|
campaign_id,
|
|
world_revision,
|
|
authority_id: authority.id.clone(),
|
|
external_subject_id: authority.subject_id.clone(),
|
|
source_subject_id: action.subject_id.clone(),
|
|
intent: action.intent.clone(),
|
|
intended_effect: action.intended_effect.clone(),
|
|
action_digest: action_digest.clone(),
|
|
public_channels: action.public_channels.clone(),
|
|
state_references: action.state_references.clone(),
|
|
status: crate::consumer::ExternalProposalStatus::Pending,
|
|
created_at,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Ok(proposals)
|
|
}
|
|
|
|
fn commit_resolution_control(
|
|
store: &CampaignStore,
|
|
row: cultcache_legacy::CultCacheEnvelope,
|
|
campaign: Campaign,
|
|
previous_resolution_epoch: u64,
|
|
operation: &str,
|
|
) -> Result<CommandResult, KernelError> {
|
|
let receipt = ResolutionControlReceipt {
|
|
schema: "ghostlight.resolution_control_receipt.v1".into(),
|
|
campaign_id: campaign.id,
|
|
world_revision: campaign.revision,
|
|
previous_resolution_epoch,
|
|
resolution_epoch: campaign.resolution_policy.resolution_epoch,
|
|
provider_configuration_epoch: campaign.resolution_policy.provider_configuration_epoch,
|
|
operation: operation.into(),
|
|
active_cell_budget: campaign.resolution_policy.active_cell_budget,
|
|
pin_ids: campaign.resolution_pins.keys().cloned().collect(),
|
|
committed_at: Utc::now(),
|
|
};
|
|
store
|
|
.append_resolution_control(&row, &campaign, &receipt)
|
|
.map_err(persist)?;
|
|
Ok(CommandResult::ResolutionUpdated { campaign, receipt })
|
|
}
|
|
|
|
fn commit(
|
|
store: &CampaignStore,
|
|
row: cultcache_legacy::CultCacheEnvelope,
|
|
mut campaign: Campaign,
|
|
kind: &str,
|
|
roll: Option<RollReceipt>,
|
|
) -> Result<CommandResult, KernelError> {
|
|
crate::resolution::ensure_agency_profiles(&mut campaign);
|
|
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,
|
|
};
|
|
store
|
|
.append_world_transition(
|
|
&row,
|
|
"ghostlight.campaign.v1",
|
|
&campaign,
|
|
&format!("{}-{}", campaign.id, campaign.revision),
|
|
&receipt,
|
|
)
|
|
.map_err(persist)?;
|
|
Ok(CommandResult::Committed { campaign, receipt })
|
|
}
|
|
|
|
fn commit_mutation_transition(
|
|
store: &CampaignStore,
|
|
row: cultcache_legacy::CultCacheEnvelope,
|
|
mut campaign: Campaign,
|
|
kind: &str,
|
|
roll: Option<RollReceipt>,
|
|
transition: crate::legacy_transition::LoweredLegacyTransition,
|
|
mutation_receipt: crate::transition::WorldMutationReceipt,
|
|
) -> Result<CommandResult, KernelError> {
|
|
crate::resolution::ensure_agency_profiles(&mut campaign);
|
|
let previous_revision = campaign.revision;
|
|
campaign.revision += 1;
|
|
if mutation_receipt.previous_world_revision != previous_revision
|
|
|| mutation_receipt.world_revision != campaign.revision
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"mutation receipt does not bind the campaign transition".into(),
|
|
));
|
|
}
|
|
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: mutation_receipt.committed_at,
|
|
roll,
|
|
};
|
|
store
|
|
.append_world_transition_with_mutation(
|
|
&row,
|
|
"ghostlight.campaign.v1",
|
|
&campaign,
|
|
&format!("{}-{}", campaign.id, campaign.revision),
|
|
&receipt,
|
|
&transition.authority,
|
|
&transition.batch,
|
|
&mutation_receipt,
|
|
)
|
|
.map_err(persist)?;
|
|
Ok(CommandResult::Committed { campaign, receipt })
|
|
}
|
|
|
|
fn load_campaign_membership(
|
|
store: &CampaignStore,
|
|
campaign_id: uuid::Uuid,
|
|
) -> Result<CampaignMembership, KernelError> {
|
|
store
|
|
.load::<CampaignMembership>("campaign_membership.v1", &campaign_id.to_string())
|
|
.map_err(persist)?
|
|
.map(|(_, membership)| membership)
|
|
.ok_or_else(|| KernelError::Invalid("campaign membership is missing".into()))
|
|
}
|
|
|
|
fn optional_campaign_membership(
|
|
store: &CampaignStore,
|
|
campaign_id: uuid::Uuid,
|
|
) -> Result<Option<CampaignMembership>, KernelError> {
|
|
store
|
|
.load::<CampaignMembership>("campaign_membership.v1", &campaign_id.to_string())
|
|
.map_err(persist)
|
|
.map(|value| value.map(|(_, membership)| membership))
|
|
}
|
|
|
|
fn validate_bounded_coop_effect(
|
|
store: &CampaignStore,
|
|
campaign: &Campaign,
|
|
acting_actor_id: &str,
|
|
effect: &WorldEffectDelta,
|
|
) -> Result<(), KernelError> {
|
|
let Some(membership) = optional_campaign_membership(store, campaign.id)? else {
|
|
return Ok(());
|
|
};
|
|
let controlled = membership.controlled_actor_ids();
|
|
if controlled.len() < 2 || !controlled.contains(acting_actor_id) {
|
|
return Ok(());
|
|
}
|
|
if !effect.actor_moves.is_empty() {
|
|
return Err(KernelError::Invalid(
|
|
"co-op travel requires a unanimous group-travel proposal".into(),
|
|
));
|
|
}
|
|
let mut protected_targets = BTreeSet::new();
|
|
protected_targets.extend(effect.actor_conditions.keys().cloned());
|
|
protected_targets.extend(effect.actor_commitments.keys().cloned());
|
|
protected_targets.extend(effect.actor_knowledge_additions.keys().cloned());
|
|
protected_targets.extend(effect.actor_observations.keys().cloned());
|
|
protected_targets.extend(effect.actor_relationship_updates.keys().cloned());
|
|
if protected_targets
|
|
.iter()
|
|
.any(|target| target != acting_actor_id && controlled.contains(target))
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"player-versus-player effects are unsupported in bounded co-op".into(),
|
|
));
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn stable_channel_id(channel: &str) -> String {
|
|
format!("{:x}", Sha256::digest(channel.as_bytes()))[..12].to_string()
|
|
}
|
|
|
|
fn require_active_member<'a>(
|
|
membership: &'a CampaignMembership,
|
|
member_id: &str,
|
|
) -> Result<&'a crate::session_zero::CampaignMember, KernelError> {
|
|
membership
|
|
.members
|
|
.get(member_id)
|
|
.filter(|member| member.active)
|
|
.ok_or_else(|| KernelError::Invalid("campaign member is not active".into()))
|
|
}
|
|
|
|
fn active_member_ids(membership: &CampaignMembership) -> BTreeSet<String> {
|
|
membership
|
|
.members
|
|
.values()
|
|
.filter(|member| member.active)
|
|
.map(|member| member.member_id.clone())
|
|
.collect()
|
|
}
|
|
|
|
fn commit_governed_time_advance(
|
|
store: &CampaignStore,
|
|
campaign_row: cultcache_legacy::CultCacheEnvelope,
|
|
mut campaign: Campaign,
|
|
proposal_row: cultcache_legacy::CultCacheEnvelope,
|
|
mut proposal: TimeAdvanceProposal,
|
|
) -> Result<CommandResult, KernelError> {
|
|
let transition = crate::legacy_transition::lower_time_advance(
|
|
&campaign,
|
|
proposal.minutes,
|
|
crate::transition::MutationProcedure::Governance,
|
|
&proposal.id,
|
|
Utc::now() + Duration::minutes(5),
|
|
)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
let mutation_receipt =
|
|
crate::legacy_transition::apply_lowered_transition(&mut campaign, &transition, Utc::now())
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
campaign.last_player_activity = Utc::now();
|
|
campaign.away_ticks_processed = 0;
|
|
campaign.pending_ticks = 0;
|
|
crate::resolution::ensure_agency_profiles(&mut campaign);
|
|
let previous_revision = campaign.revision;
|
|
campaign.revision = campaign.revision.saturating_add(1);
|
|
proposal.committed = true;
|
|
let receipt = WorldCommitReceipt {
|
|
schema: "ghostlight.world_commit_receipt.v1".into(),
|
|
campaign_id: campaign.id,
|
|
previous_revision,
|
|
revision: campaign.revision,
|
|
command_kind: "unanimous_time_advance".into(),
|
|
committed_at: mutation_receipt.committed_at,
|
|
roll: None,
|
|
};
|
|
store
|
|
.commit_time_advance(
|
|
&campaign_row,
|
|
&campaign,
|
|
&proposal_row,
|
|
&proposal,
|
|
&receipt,
|
|
(&transition.authority, &transition.batch, &mutation_receipt),
|
|
)
|
|
.map_err(persist)?;
|
|
Ok(CommandResult::Committed { campaign, receipt })
|
|
}
|
|
|
|
fn join_public_names(names: &[String]) -> String {
|
|
match names {
|
|
[] => "The party".into(),
|
|
[name] => name.clone(),
|
|
[first, second] => format!("{first} and {second}"),
|
|
_ => format!(
|
|
"{}, and {}",
|
|
names[..names.len() - 1].join(", "),
|
|
names.last().expect("non-empty names")
|
|
),
|
|
}
|
|
}
|
|
|
|
fn commit_governed_group_travel(
|
|
store: &CampaignStore,
|
|
campaign_row: cultcache_legacy::CultCacheEnvelope,
|
|
mut campaign: Campaign,
|
|
proposal_row: cultcache_legacy::CultCacheEnvelope,
|
|
mut proposal: GroupTravelProposal,
|
|
membership: &CampaignMembership,
|
|
) -> Result<CommandResult, KernelError> {
|
|
let active_actor_ids = membership.controlled_actor_ids();
|
|
if active_actor_ids.iter().any(|actor_id| {
|
|
campaign
|
|
.actors
|
|
.get(actor_id)
|
|
.is_none_or(|actor| actor.location_id != proposal.origin_location_id)
|
|
}) {
|
|
return Err(KernelError::Invalid(
|
|
"group-travel proposal no longer matches the shared scene".into(),
|
|
));
|
|
}
|
|
let route = campaign
|
|
.locations
|
|
.get(&proposal.origin_location_id)
|
|
.and_then(|location| {
|
|
location
|
|
.routes
|
|
.values()
|
|
.find(|route| route.destination_id == proposal.destination_location_id)
|
|
.cloned()
|
|
})
|
|
.ok_or_else(|| KernelError::Invalid("group-travel route no longer exists".into()))?;
|
|
if route.travel_minutes != proposal.travel_minutes {
|
|
return Err(KernelError::Invalid(
|
|
"group-travel route changed after proposal".into(),
|
|
));
|
|
}
|
|
let origin_name = campaign.locations[&proposal.origin_location_id]
|
|
.name
|
|
.clone();
|
|
let destination_name = campaign.locations[&proposal.destination_location_id]
|
|
.name
|
|
.clone();
|
|
let traveler_names = active_actor_ids
|
|
.iter()
|
|
.filter_map(|actor_id| {
|
|
campaign
|
|
.actors
|
|
.get(actor_id)
|
|
.map(|actor| actor.name.clone())
|
|
})
|
|
.collect::<Vec<_>>();
|
|
let transition = crate::legacy_transition::lower_group_travel(
|
|
&campaign,
|
|
&active_actor_ids,
|
|
&proposal.origin_location_id,
|
|
&proposal.destination_location_id,
|
|
route.travel_minutes,
|
|
&proposal.id,
|
|
Utc::now() + Duration::minutes(5),
|
|
)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
let mutation_receipt =
|
|
crate::legacy_transition::apply_lowered_transition(&mut campaign, &transition, Utc::now())
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
crate::resolution::ensure_agency_profiles(&mut campaign);
|
|
campaign.last_player_activity = Utc::now();
|
|
campaign.away_ticks_processed = 0;
|
|
campaign.pending_ticks = 0;
|
|
let previous_revision = campaign.revision;
|
|
campaign.revision = campaign.revision.saturating_add(1);
|
|
let travel_summary = format!(
|
|
"{} {} from {} to {} — {}. {} minutes pass.",
|
|
join_public_names(&traveler_names),
|
|
if traveler_names.len() == 1 {
|
|
"travels"
|
|
} else {
|
|
"travel"
|
|
},
|
|
origin_name,
|
|
destination_name,
|
|
route.distance,
|
|
route.travel_minutes
|
|
);
|
|
campaign.transcript.push(NarrativeTurn {
|
|
revision: campaign.revision,
|
|
at: campaign.world_time,
|
|
speaker: "world".into(),
|
|
text: travel_summary.clone(),
|
|
persona_response_actor_ids: BTreeSet::new(),
|
|
});
|
|
campaign.events.push(Event {
|
|
id: format!("group-travel:{}", campaign.revision),
|
|
at: campaign.world_time,
|
|
kind: "group_travel".into(),
|
|
summary: travel_summary,
|
|
actor_ids: active_actor_ids.into_iter().collect(),
|
|
institution_ids: vec![],
|
|
gestalt_ids: vec![],
|
|
location_ids: vec![
|
|
proposal.origin_location_id.clone(),
|
|
proposal.destination_location_id.clone(),
|
|
],
|
|
public_channels: vec![],
|
|
});
|
|
proposal.committed = true;
|
|
let receipt = WorldCommitReceipt {
|
|
schema: "ghostlight.world_commit_receipt.v1".into(),
|
|
campaign_id: campaign.id,
|
|
previous_revision,
|
|
revision: campaign.revision,
|
|
command_kind: "unanimous_group_travel".into(),
|
|
committed_at: mutation_receipt.committed_at,
|
|
roll: None,
|
|
};
|
|
store
|
|
.commit_group_travel(
|
|
&campaign_row,
|
|
&campaign,
|
|
&proposal_row,
|
|
&proposal,
|
|
&receipt,
|
|
(&transition.authority, &transition.batch, &mutation_receipt),
|
|
)
|
|
.map_err(persist)?;
|
|
Ok(CommandResult::Committed { campaign, receipt })
|
|
}
|
|
|
|
fn commit_governed_cell_budget(
|
|
store: &CampaignStore,
|
|
campaign_row: cultcache_legacy::CultCacheEnvelope,
|
|
mut campaign: Campaign,
|
|
proposal_row: cultcache_legacy::CultCacheEnvelope,
|
|
mut proposal: CellBudgetProposal,
|
|
) -> Result<CommandResult, KernelError> {
|
|
let previous_epoch = campaign.resolution_policy.resolution_epoch;
|
|
campaign.resolution_policy.active_cell_budget = proposal.active_cell_budget;
|
|
campaign.resolution_policy.pending_active_cell_budget = None;
|
|
campaign.resolution_policy.resolution_epoch = previous_epoch.saturating_add(1);
|
|
campaign.resolution_cover = None;
|
|
crate::resolution::validate_policy(&campaign.resolution_policy)
|
|
.map_err(|error| KernelError::Invalid(error.to_string()))?;
|
|
proposal.committed = true;
|
|
let receipt = ResolutionControlReceipt {
|
|
schema: "ghostlight.resolution_control_receipt.v1".into(),
|
|
campaign_id: campaign.id,
|
|
world_revision: campaign.revision,
|
|
previous_resolution_epoch: previous_epoch,
|
|
resolution_epoch: campaign.resolution_policy.resolution_epoch,
|
|
provider_configuration_epoch: campaign.resolution_policy.provider_configuration_epoch,
|
|
operation: "unanimous_set_active_cell_budget".into(),
|
|
active_cell_budget: campaign.resolution_policy.active_cell_budget,
|
|
pin_ids: campaign.resolution_pins.keys().cloned().collect(),
|
|
committed_at: Utc::now(),
|
|
};
|
|
store
|
|
.commit_cell_budget(&campaign_row, &campaign, &proposal_row, &proposal, &receipt)
|
|
.map_err(persist)?;
|
|
Ok(CommandResult::ResolutionUpdated { campaign, receipt })
|
|
}
|
|
|
|
fn commit_with_records(
|
|
store: &CampaignStore,
|
|
row: cultcache_legacy::CultCacheEnvelope,
|
|
mut campaign: Campaign,
|
|
kind: &str,
|
|
evidence: Vec<VaultEvidenceReceipt>,
|
|
candidates: Vec<CanonCandidate>,
|
|
model_receipts: Vec<crate::model::ModelStageReceipt>,
|
|
mutation: Option<(
|
|
crate::legacy_transition::LoweredLegacyTransition,
|
|
crate::transition::WorldMutationReceipt,
|
|
)>,
|
|
) -> Result<CommandResult, KernelError> {
|
|
crate::resolution::ensure_agency_profiles(&mut campaign);
|
|
let previous_revision = campaign.revision;
|
|
campaign.revision += 1;
|
|
if let Some((_, mutation_receipt)) = &mutation
|
|
&& (mutation_receipt.previous_world_revision != previous_revision
|
|
|| mutation_receipt.world_revision != campaign.revision)
|
|
{
|
|
return Err(KernelError::Invalid(
|
|
"mutation receipt does not bind the recorded world commit".into(),
|
|
));
|
|
}
|
|
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: mutation
|
|
.as_ref()
|
|
.map(|(_, receipt)| receipt.committed_at)
|
|
.unwrap_or_else(Utc::now),
|
|
roll: None,
|
|
};
|
|
store
|
|
.append_world_commit(
|
|
&row,
|
|
&campaign,
|
|
&format!("{}-{}", campaign.id, campaign.revision),
|
|
&receipt,
|
|
&evidence,
|
|
&candidates,
|
|
&model_receipts,
|
|
mutation
|
|
.as_ref()
|
|
.map(|(transition, receipt)| (&transition.authority, &transition.batch, receipt)),
|
|
)
|
|
.map_err(persist)?;
|
|
Ok(CommandResult::Committed { campaign, receipt })
|
|
}
|
|
|
|
fn persist(e: anyhow::Error) -> KernelError {
|
|
KernelError::Persistence(e.to_string())
|
|
}
|
|
|
|
#[cfg(test)]
|
|
pub(crate) mod tests {
|
|
use super::*;
|
|
use sha2::{Digest, Sha256};
|
|
use std::collections::{BTreeMap, BTreeSet};
|
|
|
|
fn test_action_digest(label: &str) -> String {
|
|
format!("sha256:{:x}", Sha256::digest(label.as_bytes()))
|
|
}
|
|
|
|
#[test]
|
|
fn strategic_activity_phase_is_derived_from_exact_locations() {
|
|
assert_eq!(
|
|
relative_activity_phase("yard", Some("room"), &["yard".into()]),
|
|
0
|
|
);
|
|
assert_eq!(
|
|
relative_activity_phase("yard", Some("room"), &["room".into()]),
|
|
2
|
|
);
|
|
assert_eq!(
|
|
relative_activity_phase("yard", Some("room"), &["yard".into(), "room".into()]),
|
|
1
|
|
);
|
|
assert_eq!(relative_activity_phase("yard", None, &["yard".into()]), 1);
|
|
}
|
|
|
|
fn resolve_test_activities(mut plan: StrategicTickPlan) -> StrategicTickPlan {
|
|
plan.activity_outcomes.extend(
|
|
plan.gestalt_activities
|
|
.iter()
|
|
.map(|activity| (activity.action_digest.clone(), activity.gestalt_id.clone()))
|
|
.chain(
|
|
plan.actor_activities.iter().map(|activity| {
|
|
(activity.action_digest.clone(), activity.actor_id.clone())
|
|
}),
|
|
)
|
|
.chain(plan.member_activities.iter().map(|activity| {
|
|
(
|
|
activity.action_digest.clone(),
|
|
crate::domain::gestalt_member_subject_id(&activity.member_id),
|
|
)
|
|
}))
|
|
.map(
|
|
|(action_digest, source_subject_id)| StrategicActivityOutcome {
|
|
schema: "ghostlight.strategic_activity_outcome.v1".into(),
|
|
action_digest,
|
|
source_subject_id,
|
|
band: StrategicOutcomeBand::Mixed,
|
|
summary: "The attempt produces no durable material change.".into(),
|
|
supporting_state_references: vec![],
|
|
effect: StrategicOutcomeEffect::NoMaterialChange {
|
|
reason: "No response is established in this test snapshot.".into(),
|
|
},
|
|
},
|
|
),
|
|
);
|
|
plan
|
|
}
|
|
|
|
fn assert_only_strategic_obligations_advanced(before: &Campaign, after: &Campaign) {
|
|
let mut expected = before.clone();
|
|
expected.world_time += Duration::hours(i64::from(expected.tick_hours));
|
|
for clock in expected.clocks.values_mut() {
|
|
clock.progress = clock.progress.saturating_add(1).min(clock.threshold);
|
|
}
|
|
assert_eq!(after, &expected);
|
|
}
|
|
|
|
pub(crate) fn campaign() -> Campaign {
|
|
let id = uuid::Uuid::new_v4();
|
|
let actor = ActorState {
|
|
id: "player".into(),
|
|
name: "Player".into(),
|
|
location_id: "room".into(),
|
|
capabilities: BTreeSet::new(),
|
|
knowledge: BTreeSet::new(),
|
|
equipment: BTreeSet::new(),
|
|
conditions: BTreeSet::new(),
|
|
obligations: BTreeSet::new(),
|
|
relationships: BTreeMap::new(),
|
|
goals: vec![],
|
|
memories: vec![],
|
|
};
|
|
Campaign {
|
|
schema: "ghostlight.campaign.v1".into(),
|
|
id,
|
|
name: "Test".into(),
|
|
revision: 0,
|
|
branch_origin: BranchOrigin {
|
|
canon_cutoff: "test".into(),
|
|
evidence_receipt_ids: vec![],
|
|
},
|
|
world_time: Utc::now(),
|
|
tick_hours: 6,
|
|
player_actor_id: "player".into(),
|
|
locations: BTreeMap::from([(
|
|
"room".into(),
|
|
Location {
|
|
id: "room".into(),
|
|
name: "Room".into(),
|
|
container_id: None,
|
|
routes: BTreeMap::new(),
|
|
persistent_features: vec!["stable".into()],
|
|
},
|
|
)]),
|
|
actors: BTreeMap::from([("player".into(), actor)]),
|
|
institutions: BTreeMap::new(),
|
|
clocks: BTreeMap::new(),
|
|
facts: BTreeMap::new(),
|
|
civic_systems: BTreeMap::new(),
|
|
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![],
|
|
agency_profiles: BTreeMap::new(),
|
|
agency_relations: BTreeMap::new(),
|
|
gestalt_lineages: BTreeMap::new(),
|
|
resolution_policy: Default::default(),
|
|
resolution_pins: BTreeMap::new(),
|
|
resolution_cover: None,
|
|
strategic_tick_count: 0,
|
|
}
|
|
}
|
|
|
|
fn civic_locality_elaboration() -> LocalityElaboration {
|
|
let public_facts = [
|
|
(
|
|
"fact:room-authority",
|
|
"Mayor Selka Vey holds the civic seal while the ward assembly controls appropriations.",
|
|
),
|
|
(
|
|
"fact:room-selection",
|
|
"Residents elected Selka Vey over Oren Vale at the last mayoral ballot.",
|
|
),
|
|
(
|
|
"fact:room-resources",
|
|
"Published berth dues fund the civic treasury.",
|
|
),
|
|
(
|
|
"fact:room-redress",
|
|
"Residents may appeal a mayoral order to the ward petitions bench.",
|
|
),
|
|
];
|
|
let facts = public_facts
|
|
.iter()
|
|
.map(|(id, statement)| WorldFact {
|
|
id: (*id).into(),
|
|
statement: (*statement).into(),
|
|
scope: FactScope::BranchLocal,
|
|
evidence_receipt_ids: vec![],
|
|
discoverable_at_location_ids: BTreeSet::from([
|
|
"room".into(),
|
|
"civic-quarter".into(),
|
|
]),
|
|
})
|
|
.collect::<Vec<_>>();
|
|
let institution_profile = |id: &str, authority: &str| AgencyProfile {
|
|
schema: "ghostlight.agency_profile.v1".into(),
|
|
id: format!("agency:{id}"),
|
|
subject_id: id.into(),
|
|
subject_kind: AgencySubjectKind::Institution,
|
|
profile_version: 0,
|
|
collective_authority_id: None,
|
|
parent_subject_id: None,
|
|
active_leaf: true,
|
|
simulation_eligible: true,
|
|
facets: BTreeMap::from([
|
|
(AgencyAxis::Geography, BTreeSet::from(["room".into()])),
|
|
(
|
|
AgencyAxis::Ideology,
|
|
BTreeSet::from(["public mandate".into()]),
|
|
),
|
|
(AgencyAxis::Authority, BTreeSet::from([authority.into()])),
|
|
(
|
|
AgencyAxis::EconomyRole,
|
|
BTreeSet::from(["civic administration".into()]),
|
|
),
|
|
(
|
|
AgencyAxis::SpeciesBody,
|
|
BTreeSet::from(["mixed residents".into()]),
|
|
),
|
|
(
|
|
AgencyAxis::Information,
|
|
BTreeSet::from(["ward notices".into()]),
|
|
),
|
|
]),
|
|
location_ids: BTreeSet::from(["civic-quarter".into()]),
|
|
information_channels: BTreeSet::from(["ward notice board".into()]),
|
|
detail_debt: 0,
|
|
last_detail_tick: 0,
|
|
evidence_receipt_ids: vec![],
|
|
};
|
|
LocalityElaboration {
|
|
target_location_id: "room".into(),
|
|
expansion: RegionExpansion {
|
|
origin_location_id: "room".into(),
|
|
origin_routes: BTreeMap::from([(
|
|
"to-civic-quarter".into(),
|
|
Route {
|
|
destination_id: "civic-quarter".into(),
|
|
distance: "through the public arcade".into(),
|
|
travel_minutes: 5,
|
|
},
|
|
)]),
|
|
locations: vec![Location {
|
|
id: "civic-quarter".into(),
|
|
name: "Civic Quarter".into(),
|
|
container_id: Some("room".into()),
|
|
routes: BTreeMap::from([(
|
|
"to-room".into(),
|
|
Route {
|
|
destination_id: "room".into(),
|
|
distance: "back through the public arcade".into(),
|
|
travel_minutes: 5,
|
|
},
|
|
)]),
|
|
persistent_features: vec!["sealed ballot archive".into()],
|
|
}],
|
|
facts,
|
|
populations: vec![GestaltPersonaState {
|
|
schema: "ghostlight.gestalt_persona_state.v1".into(),
|
|
id: "room-residents".into(),
|
|
name: "Room residents".into(),
|
|
version: 0,
|
|
home_location_id: "civic-quarter".into(),
|
|
shared_capabilities: BTreeSet::from(["participate in ward ballots".into()]),
|
|
shared_knowledge: public_facts
|
|
.iter()
|
|
.map(|(_, statement)| (*statement).into())
|
|
.collect(),
|
|
resources: BTreeSet::from(["ward hall".into()]),
|
|
goals: vec!["keep the treasury answerable".into()],
|
|
pressures: vec!["the mayor and assembly dispute appropriations".into()],
|
|
}],
|
|
population_profiles: vec![AgencyProfile {
|
|
schema: "ghostlight.agency_profile.v1".into(),
|
|
id: "agency:room-residents".into(),
|
|
subject_id: "room-residents".into(),
|
|
subject_kind: AgencySubjectKind::Gestalt,
|
|
profile_version: 0,
|
|
collective_authority_id: Some("room-residents".into()),
|
|
parent_subject_id: None,
|
|
active_leaf: true,
|
|
simulation_eligible: true,
|
|
facets: BTreeMap::from([
|
|
(AgencyAxis::Geography, BTreeSet::from(["room".into()])),
|
|
(
|
|
AgencyAxis::Ideology,
|
|
BTreeSet::from(["ward representation".into()]),
|
|
),
|
|
(
|
|
AgencyAxis::Authority,
|
|
BTreeSet::from(["resident franchise".into()]),
|
|
),
|
|
(
|
|
AgencyAxis::EconomyRole,
|
|
BTreeSet::from(["berth work".into()]),
|
|
),
|
|
(
|
|
AgencyAxis::SpeciesBody,
|
|
BTreeSet::from(["mixed residents".into()]),
|
|
),
|
|
(
|
|
AgencyAxis::Information,
|
|
BTreeSet::from(["ward notices".into()]),
|
|
),
|
|
]),
|
|
location_ids: BTreeSet::from(["civic-quarter".into()]),
|
|
information_channels: BTreeSet::from(["ward notice board".into()]),
|
|
detail_debt: 0,
|
|
last_detail_tick: 0,
|
|
evidence_receipt_ids: vec![],
|
|
}],
|
|
migration_relations: vec![],
|
|
institutions: vec![
|
|
InstitutionState {
|
|
id: "mayoral-office".into(),
|
|
name: "Mayoral Office".into(),
|
|
resources: vec!["civic seal".into()],
|
|
goals: vec!["retain emergency spending discretion".into()],
|
|
posture: "press for immediate appropriation".into(),
|
|
},
|
|
InstitutionState {
|
|
id: "ward-assembly".into(),
|
|
name: "Ward Assembly".into(),
|
|
resources: vec!["appropriations ledger".into()],
|
|
goals: vec!["bind spending to public accounts".into()],
|
|
posture: "withhold funds pending audit".into(),
|
|
},
|
|
],
|
|
institution_profiles: vec![
|
|
institution_profile("mayoral-office", "mayoral orders"),
|
|
institution_profile("ward-assembly", "appropriations"),
|
|
],
|
|
local_relations: vec![AgencyRelation {
|
|
schema: "ghostlight.agency_relation.v1".into(),
|
|
id: "relation:mayor-assembly".into(),
|
|
from_subject_id: "mayoral-office".into(),
|
|
to_subject_id: "ward-assembly".into(),
|
|
kind: AgencyRelationKind::Rivalry,
|
|
strength: 72,
|
|
active: true,
|
|
evidence_receipt_ids: vec![],
|
|
}],
|
|
civic_system: Some(CivicSystemManifest {
|
|
schema: "ghostlight.civic_system_manifest.v1".into(),
|
|
version: 0,
|
|
jurisdiction_location_id: "room".into(),
|
|
governing_institution_ids: BTreeSet::from([
|
|
"mayoral-office".into(),
|
|
"ward-assembly".into(),
|
|
]),
|
|
resident_population_ids: BTreeSet::from(["room-residents".into()]),
|
|
public_authority_fact_ids: BTreeSet::from(["fact:room-authority".into()]),
|
|
public_selection_fact_ids: BTreeSet::from(["fact:room-selection".into()]),
|
|
public_resource_fact_ids: BTreeSet::from(["fact:room-resources".into()]),
|
|
public_redress_fact_ids: BTreeSet::from(["fact:room-redress".into()]),
|
|
political_relation_ids: BTreeSet::from(["relation:mayor-assembly".into()]),
|
|
semantic_verification_receipt_id: String::new(),
|
|
}),
|
|
},
|
|
}
|
|
}
|
|
|
|
fn civic_verifier_receipt(
|
|
campaign: &Campaign,
|
|
expansion: &mut RegionExpansion,
|
|
) -> crate::model::ModelStageReceipt {
|
|
let digest = crate::compiler::civic_candidate_digest(expansion).unwrap();
|
|
let mut receipt = crate::model::ModelStageReceipt {
|
|
schema: "ghostlight.persona_stage_receipt.v1".into(),
|
|
receipt_hash: String::new(),
|
|
provider: "fixture".into(),
|
|
model: "fixture".into(),
|
|
stage: "destination_civic_verification".into(),
|
|
snapshot_binding: String::new(),
|
|
request_hash: test_action_digest("civic-verifier-request"),
|
|
output_hash: test_action_digest("civic-verifier-output"),
|
|
source_receipt_ids: vec![],
|
|
latency_ms: 1,
|
|
validation_result: "valid".into(),
|
|
local_validation_error: None,
|
|
input_chars: 1,
|
|
output_chars: 1,
|
|
provider_attempts: vec![],
|
|
};
|
|
receipt.rebind_snapshot(crate::compiler::civic_verifier_binding(campaign, &digest));
|
|
expansion
|
|
.civic_system
|
|
.as_mut()
|
|
.unwrap()
|
|
.semantic_verification_receipt_id = receipt.storage_key().to_owned();
|
|
receipt
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn resolved_outcome_cannot_admit_an_unrequested_gestalt_member() {
|
|
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.transcript.push(NarrativeTurn {
|
|
revision: 0,
|
|
at: Utc::now(),
|
|
speaker: "world".into(),
|
|
text: "They agree to help design the relay.".into(),
|
|
persona_response_actor_ids: BTreeSet::new(),
|
|
});
|
|
seed.gestalts.insert(
|
|
"refugees".into(),
|
|
GestaltPersonaState {
|
|
schema: "ghostlight.gestalt_persona_state.v1".into(),
|
|
id: "refugees".into(),
|
|
name: "Refugees".into(),
|
|
version: 0,
|
|
home_location_id: "room".into(),
|
|
shared_capabilities: BTreeSet::new(),
|
|
shared_knowledge: BTreeSet::new(),
|
|
resources: BTreeSet::new(),
|
|
goals: vec![],
|
|
pressures: vec![],
|
|
},
|
|
);
|
|
crate::resolution::ensure_agency_profiles(&mut seed);
|
|
let campaign_id = seed.id;
|
|
kernel
|
|
.command(WorldCommand::CreateCampaign {
|
|
campaign: seed,
|
|
evidence_receipts: vec![],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
|
|
let member = GestaltMemberDelta {
|
|
schema: "ghostlight.gestalt_member_delta.v1".into(),
|
|
id: "relay-volunteer".into(),
|
|
gestalt_id: "refugees".into(),
|
|
version: 0,
|
|
name: "Relay Volunteer".into(),
|
|
capability_additions: BTreeSet::new(),
|
|
capability_removals: BTreeSet::new(),
|
|
knowledge_additions: BTreeSet::new(),
|
|
knowledge_removals: BTreeSet::new(),
|
|
equipment: BTreeSet::new(),
|
|
conditions: BTreeSet::new(),
|
|
obligations: BTreeSet::new(),
|
|
relationships: BTreeMap::new(),
|
|
goals: vec!["help with the relay".into()],
|
|
memories: vec!["agreed to help".into()],
|
|
last_location_id: Some("room".into()),
|
|
materialized_actor_id: None,
|
|
last_relevant_revision: 0,
|
|
relevance_lease_until_revision: 0,
|
|
};
|
|
let error = kernel
|
|
.command(WorldCommand::ReconcileGestaltPresence {
|
|
expected_revision: 0,
|
|
reason: "They agree to help design the relay.".into(),
|
|
plan: GestaltPresencePlan {
|
|
individuations: vec![GestaltIndividuation {
|
|
gestalt_id: "refugees".into(),
|
|
expected_gestalt_version: 0,
|
|
member,
|
|
location_id: "room".into(),
|
|
}],
|
|
promotions: vec![],
|
|
demotions: vec![],
|
|
},
|
|
})
|
|
.await
|
|
.unwrap_err();
|
|
assert!(
|
|
error
|
|
.to_string()
|
|
.contains("immediately committed player speech")
|
|
);
|
|
let persisted = store
|
|
.load::<Campaign>("campaign.v1", &campaign_id.to_string())
|
|
.unwrap()
|
|
.unwrap()
|
|
.1;
|
|
assert_eq!(persisted.revision, 0);
|
|
assert!(persisted.gestalt_members.is_empty());
|
|
assert_eq!(persisted.transcript.len(), 1);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn kernel_rejects_individuation_that_duplicates_addressed_actor_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();
|
|
seed.actors.insert(
|
|
"taren".into(),
|
|
ActorState {
|
|
id: "taren".into(),
|
|
name: "Taren".into(),
|
|
location_id: "room".into(),
|
|
capabilities: BTreeSet::new(),
|
|
knowledge: BTreeSet::new(),
|
|
equipment: BTreeSet::new(),
|
|
conditions: BTreeSet::new(),
|
|
obligations: BTreeSet::new(),
|
|
relationships: BTreeMap::new(),
|
|
goals: vec![],
|
|
memories: vec![],
|
|
},
|
|
);
|
|
seed.gestalts.insert(
|
|
"refugees".into(),
|
|
GestaltPersonaState {
|
|
schema: "ghostlight.gestalt_persona_state.v1".into(),
|
|
id: "refugees".into(),
|
|
name: "Refugees".into(),
|
|
version: 0,
|
|
home_location_id: "room".into(),
|
|
shared_capabilities: BTreeSet::new(),
|
|
shared_knowledge: BTreeSet::new(),
|
|
resources: BTreeSet::new(),
|
|
goals: vec![],
|
|
pressures: vec![],
|
|
},
|
|
);
|
|
let speech = "Taren, tell me whether the regulator is holding.";
|
|
let reason = format!("{} says: {speech}", seed.player_actor_id);
|
|
seed.transcript.push(NarrativeTurn {
|
|
revision: 0,
|
|
at: Utc::now(),
|
|
speaker: seed.player_actor_id.clone(),
|
|
text: speech.into(),
|
|
persona_response_actor_ids: BTreeSet::from(["taren".into()]),
|
|
});
|
|
crate::resolution::ensure_agency_profiles(&mut seed);
|
|
let campaign_id = seed.id;
|
|
kernel
|
|
.command(WorldCommand::CreateCampaign {
|
|
campaign: seed,
|
|
evidence_receipts: vec![],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
|
|
let error = kernel
|
|
.command(WorldCommand::ReconcileGestaltPresence {
|
|
expected_revision: 0,
|
|
reason,
|
|
plan: GestaltPresencePlan {
|
|
individuations: vec![GestaltIndividuation {
|
|
gestalt_id: "refugees".into(),
|
|
expected_gestalt_version: 0,
|
|
member: GestaltMemberDelta {
|
|
schema: "ghostlight.gestalt_member_delta.v1".into(),
|
|
id: "second-taren".into(),
|
|
gestalt_id: "refugees".into(),
|
|
version: 0,
|
|
name: " tArEn ".into(),
|
|
capability_additions: BTreeSet::new(),
|
|
capability_removals: BTreeSet::new(),
|
|
knowledge_additions: BTreeSet::new(),
|
|
knowledge_removals: BTreeSet::new(),
|
|
equipment: BTreeSet::new(),
|
|
conditions: BTreeSet::new(),
|
|
obligations: BTreeSet::new(),
|
|
relationships: BTreeMap::new(),
|
|
goals: vec![],
|
|
memories: vec![],
|
|
last_location_id: Some("room".into()),
|
|
materialized_actor_id: None,
|
|
last_relevant_revision: 0,
|
|
relevance_lease_until_revision: 0,
|
|
},
|
|
location_id: "room".into(),
|
|
}],
|
|
promotions: vec![],
|
|
demotions: vec![],
|
|
},
|
|
})
|
|
.await
|
|
.unwrap_err();
|
|
assert!(error.to_string().contains("already-addressed actor"));
|
|
let persisted = store
|
|
.load::<Campaign>("campaign.v1", &campaign_id.to_string())
|
|
.unwrap()
|
|
.unwrap()
|
|
.1;
|
|
assert_eq!(persisted.revision, 0);
|
|
assert!(!persisted.gestalt_members.contains_key("second-taren"));
|
|
assert_eq!(persisted.actors["taren"].name, "Taren");
|
|
}
|
|
|
|
#[test]
|
|
fn composite_selected_action_commits_atomically_and_rebuilds_derived_lanes() {
|
|
let mut value = campaign();
|
|
value.locations.insert(
|
|
"yard".into(),
|
|
Location {
|
|
id: "yard".into(),
|
|
name: "Yard".into(),
|
|
container_id: None,
|
|
routes: BTreeMap::new(),
|
|
persistent_features: vec![],
|
|
},
|
|
);
|
|
value.locations.get_mut("room").unwrap().routes.insert(
|
|
"yard-route".into(),
|
|
crate::domain::Route {
|
|
destination_id: "yard".into(),
|
|
distance: "nearby".into(),
|
|
travel_minutes: 15,
|
|
},
|
|
);
|
|
let mut runner = value.actors["player"].clone();
|
|
runner.id = "runner".into();
|
|
runner.name = "Runner".into();
|
|
value.actors.insert(runner.id.clone(), runner);
|
|
crate::resolution::ensure_agency_profiles(&mut value);
|
|
let proposal = CellActionProposal {
|
|
subject_id: "runner".into(),
|
|
intent: "cross into the yard, inspect it, and brace one loose gate".into(),
|
|
intended_effect: "arrive, identify one local hazard, and attempt a bounded repair"
|
|
.into(),
|
|
priority: 80,
|
|
state_references: vec!["subject:runner".into()],
|
|
public_channels: vec![],
|
|
effects: vec![
|
|
StrategicCellEffect::ActorMove {
|
|
actor_id: "runner".into(),
|
|
destination_id: "yard".into(),
|
|
},
|
|
StrategicCellEffect::ActorActivity {
|
|
actor_id: "runner".into(),
|
|
activity: StrategicActivityKind::Investigate,
|
|
target_subject_ids: vec![],
|
|
location_ids: vec!["yard".into()],
|
|
},
|
|
StrategicCellEffect::ActorActivity {
|
|
actor_id: "runner".into(),
|
|
activity: StrategicActivityKind::Prepare,
|
|
target_subject_ids: vec![],
|
|
location_ids: vec!["yard".into()],
|
|
},
|
|
],
|
|
};
|
|
let digest = crate::resolution::cell_action_digest(&proposal).unwrap();
|
|
let mut plan = crate::resolution::project_selected_actions(&value, vec![proposal]).unwrap();
|
|
plan.activity_outcomes = vec![StrategicActivityOutcome {
|
|
schema: "ghostlight.strategic_activity_outcome.v1".into(),
|
|
action_digest: digest,
|
|
source_subject_id: "runner".into(),
|
|
band: StrategicOutcomeBand::Success,
|
|
summary: "Runner completes the inspection without a durable discovery.".into(),
|
|
supporting_state_references: vec![],
|
|
effect: StrategicOutcomeEffect::NoMaterialChange {
|
|
reason: "The inspection reveals no durable new fact.".into(),
|
|
},
|
|
}];
|
|
plan.actor_moves = vec![StrategicActorMove {
|
|
actor_id: "player".into(),
|
|
destination_id: "invented".into(),
|
|
public_channels: vec![],
|
|
}];
|
|
|
|
let applied = apply_strategic_tick_plan(&mut value, plan).unwrap();
|
|
|
|
assert_eq!(value.actors["runner"].location_id, "yard");
|
|
assert_eq!(value.actors["player"].location_id, "room");
|
|
assert_eq!(
|
|
applied
|
|
.events
|
|
.iter()
|
|
.map(|event| event.kind.as_str())
|
|
.collect::<Vec<_>>(),
|
|
vec!["actor_movement", "actor_activity", "actor_activity"]
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn mailbox_commits_one_authorized_component_mutation_batch_atomically() {
|
|
use crate::transition::*;
|
|
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let store = CampaignStore::open(dir.path().join("campaign.cc")).unwrap();
|
|
let campaign_id = uuid::Uuid::new_v4();
|
|
let campaign_subject = SubjectRef {
|
|
kind: SubjectKind::Campaign,
|
|
id: campaign_id.to_string(),
|
|
};
|
|
let state = ComponentWorldState {
|
|
schema: "ghostlight.component_world_state.v1".into(),
|
|
campaign_id,
|
|
revision: 7,
|
|
resolution_epoch: 3,
|
|
world_time: Utc::now(),
|
|
subjects: BTreeMap::from([(
|
|
campaign_subject.clone(),
|
|
TypedSubject {
|
|
schema: "ghostlight.typed_subject.v1".into(),
|
|
subject: campaign_subject.clone(),
|
|
lifecycle: LifecycleStatus::Active,
|
|
admitted_components: BTreeSet::from([WorldComponentKind::WorldTime]),
|
|
version: 7,
|
|
},
|
|
)]),
|
|
occupancy: BTreeMap::new(),
|
|
custody: BTreeMap::new(),
|
|
resources: BTreeMap::new(),
|
|
capabilities: BTreeMap::new(),
|
|
conditions: BTreeMap::new(),
|
|
commitments: BTreeMap::new(),
|
|
relationships: BTreeMap::new(),
|
|
pressures: BTreeMap::new(),
|
|
knowledge: BTreeMap::new(),
|
|
memories: BTreeMap::new(),
|
|
postures: BTreeMap::new(),
|
|
memberships: BTreeMap::new(),
|
|
population_lineages: BTreeMap::new(),
|
|
identities: BTreeMap::new(),
|
|
place_profiles: BTreeMap::new(),
|
|
propositions: BTreeMap::new(),
|
|
topology: BTreeMap::new(),
|
|
civic_systems: BTreeMap::new(),
|
|
};
|
|
let initial_world_time = state.world_time;
|
|
store.create_component_world_state(&state).unwrap();
|
|
|
|
let permit = MutationPermit {
|
|
id: "permit:time".into(),
|
|
operation: WorldMutationOperation::AdvanceWorldTime,
|
|
subject_bindings: vec![MutationSubjectBinding {
|
|
role: MutationSubjectRole::Subject,
|
|
allowed_subjects: BTreeSet::from([campaign_subject.clone()]),
|
|
}],
|
|
string_constraints: BTreeMap::new(),
|
|
integer_bounds: BTreeMap::from([(
|
|
MutationIntegerRole::WorldMinutes,
|
|
IntegerBounds {
|
|
minimum: 30,
|
|
maximum: 30,
|
|
},
|
|
)]),
|
|
exact_mutation: None,
|
|
maximum_uses: 1,
|
|
};
|
|
let mut authority = MutationAuthorityEnvelope {
|
|
schema: "ghostlight.mutation_authority_envelope.v1".into(),
|
|
id: "authority:time".into(),
|
|
campaign_id,
|
|
world_revision: 7,
|
|
resolution_epoch: Some(3),
|
|
procedure: MutationProcedure::Governance,
|
|
source_subject: None,
|
|
outcome: MutationOutcomeBinding::Deterministic,
|
|
effect_ceiling: "Thirty minutes pass; no other component changes.".into(),
|
|
permits: vec![permit],
|
|
authority_receipt_ids: BTreeSet::from(["governance:time".into()]),
|
|
expires_at: Utc::now() + Duration::minutes(5),
|
|
digest: String::new(),
|
|
};
|
|
authority.digest = envelope_digest(&authority).unwrap();
|
|
let mut batch = WorldMutationBatch {
|
|
schema: "ghostlight.world_mutation_batch.v1".into(),
|
|
id: "batch:time".into(),
|
|
campaign_id,
|
|
expected_world_revision: 7,
|
|
expected_resolution_epoch: Some(3),
|
|
authority_envelope_digest: authority.digest.clone(),
|
|
source_receipt_id: "governance:time".into(),
|
|
means_digest: None,
|
|
intended_effect_digest: None,
|
|
mutations: vec![PermittedWorldMutation {
|
|
permit_id: "permit:time".into(),
|
|
mutation: WorldMutation::AdvanceWorldTime {
|
|
campaign: campaign_subject,
|
|
minutes: 30,
|
|
},
|
|
}],
|
|
digest: String::new(),
|
|
};
|
|
batch.digest = mutation_batch_digest(&batch).unwrap();
|
|
|
|
let kernel = WorldKernel::start(store.clone());
|
|
let committed = kernel
|
|
.commit_mutation_batch(authority.clone(), batch.clone())
|
|
.await
|
|
.unwrap();
|
|
let CommandResult::MutationCommitted { state, receipt } = committed else {
|
|
panic!("component mutation did not return its typed receipt");
|
|
};
|
|
assert_eq!(state.revision, 8);
|
|
assert_eq!(state.world_time, initial_world_time + Duration::minutes(30));
|
|
assert_eq!(receipt.previous_world_revision, 7);
|
|
assert_eq!(receipt.world_revision, 8);
|
|
assert_eq!(store.keys("world_mutation_receipt.v1").unwrap().len(), 1);
|
|
|
|
assert!(
|
|
kernel
|
|
.commit_mutation_batch(authority.clone(), batch.clone())
|
|
.await
|
|
.is_err()
|
|
);
|
|
let stored = store
|
|
.load::<ComponentWorldState>("component_world_state.v1", &campaign_id.to_string())
|
|
.unwrap()
|
|
.unwrap()
|
|
.1;
|
|
assert_eq!(stored.revision, 8);
|
|
assert_eq!(store.keys("world_mutation_receipt.v1").unwrap().len(), 1);
|
|
|
|
let mut aggregate = campaign();
|
|
aggregate.id = campaign_id;
|
|
store
|
|
.create_unadmitted_fixture_campaign(&aggregate, &[], &[])
|
|
.unwrap();
|
|
let error = kernel
|
|
.commit_mutation_batch(authority, batch)
|
|
.await
|
|
.unwrap_err();
|
|
assert!(
|
|
error
|
|
.to_string()
|
|
.contains("only through their WorldCommand mailbox")
|
|
);
|
|
let stored = store
|
|
.load::<ComponentWorldState>("component_world_state.v1", &campaign_id.to_string())
|
|
.unwrap()
|
|
.unwrap()
|
|
.1;
|
|
assert_eq!(stored.revision, 8);
|
|
assert_eq!(store.keys("world_mutation_receipt.v1").unwrap().len(), 1);
|
|
}
|
|
|
|
fn hierarchical_refugee_campaign() -> Campaign {
|
|
let mut value = campaign();
|
|
value.locations.insert(
|
|
"camp".into(),
|
|
Location {
|
|
id: "camp".into(),
|
|
name: "Transit camp".into(),
|
|
container_id: None,
|
|
routes: BTreeMap::from([(
|
|
"to-docks".into(),
|
|
Route {
|
|
destination_id: "docks".into(),
|
|
distance: "across the bay".into(),
|
|
travel_minutes: 90,
|
|
},
|
|
)]),
|
|
persistent_features: vec!["departure board".into()],
|
|
},
|
|
);
|
|
value.locations.insert(
|
|
"docks".into(),
|
|
Location {
|
|
id: "docks".into(),
|
|
name: "South docks".into(),
|
|
container_id: None,
|
|
routes: BTreeMap::new(),
|
|
persistent_features: vec!["net lofts".into()],
|
|
},
|
|
);
|
|
let gestalt = |id: &str,
|
|
name: &str,
|
|
location: &str,
|
|
capabilities: &[&str],
|
|
knowledge: &[&str],
|
|
goals: &[&str]| GestaltPersonaState {
|
|
schema: "ghostlight.gestalt_persona_state.v1".into(),
|
|
id: id.into(),
|
|
name: name.into(),
|
|
version: 0,
|
|
home_location_id: location.into(),
|
|
shared_capabilities: capabilities.iter().map(|value| (*value).into()).collect(),
|
|
shared_knowledge: knowledge.iter().map(|value| (*value).into()).collect(),
|
|
resources: BTreeSet::new(),
|
|
goals: goals.iter().map(|value| (*value).into()).collect(),
|
|
pressures: vec![],
|
|
};
|
|
value.gestalts.insert(
|
|
"refugees-east".into(),
|
|
gestalt(
|
|
"refugees-east",
|
|
"Eastern transit refugees",
|
|
"camp",
|
|
&["survive transit", "speak old dialect"],
|
|
&["camp alarm", "old village"],
|
|
&["find safety"],
|
|
),
|
|
);
|
|
value.gestalts.insert(
|
|
"dock-neighbors".into(),
|
|
gestalt(
|
|
"dock-neighbors",
|
|
"South dock neighbors",
|
|
"docks",
|
|
&["repair nets"],
|
|
&["harbor routines", "public bulletin"],
|
|
&["keep the docks running"],
|
|
),
|
|
);
|
|
value.gestalt_members.insert(
|
|
"mira".into(),
|
|
GestaltMemberDelta {
|
|
schema: "ghostlight.gestalt_member_delta.v1".into(),
|
|
id: "mira".into(),
|
|
gestalt_id: "refugees-east".into(),
|
|
version: 3,
|
|
name: "Mira Venn".into(),
|
|
capability_additions: BTreeSet::from(["weave signal cord".into()]),
|
|
capability_removals: BTreeSet::from(["speak old dialect".into()]),
|
|
knowledge_additions: BTreeSet::from(["the player kept a promise".into()]),
|
|
knowledge_removals: BTreeSet::from(["camp alarm".into()]),
|
|
equipment: BTreeSet::from(["patched blue satchel".into()]),
|
|
conditions: BTreeSet::from(["healed burn scar".into()]),
|
|
obligations: BTreeSet::from(["repay the player's help".into()]),
|
|
relationships: BTreeMap::from([(
|
|
"player".into(),
|
|
"trusts them for opening the evacuation gate".into(),
|
|
)]),
|
|
goals: vec![],
|
|
memories: vec!["The player carried her brother through the smoke.".into()],
|
|
last_location_id: Some("camp".into()),
|
|
materialized_actor_id: None,
|
|
last_relevant_revision: 7,
|
|
relevance_lease_until_revision: 0,
|
|
},
|
|
);
|
|
crate::resolution::ensure_agency_profiles(&mut value);
|
|
value
|
|
.agency_profiles
|
|
.get_mut("refugees-east")
|
|
.unwrap()
|
|
.parent_subject_id = Some("refugees-by-destination".into());
|
|
value
|
|
.agency_profiles
|
|
.get_mut("dock-neighbors")
|
|
.unwrap()
|
|
.parent_subject_id = Some("southport-populations".into());
|
|
value.agency_relations.insert(
|
|
"refugee-resettlement".into(),
|
|
AgencyRelation {
|
|
schema: "ghostlight.agency_relation.v1".into(),
|
|
id: "refugee-resettlement".into(),
|
|
from_subject_id: "refugees-east".into(),
|
|
to_subject_id: "dock-neighbors".into(),
|
|
kind: AgencyRelationKind::Migration,
|
|
strength: 90,
|
|
active: true,
|
|
evidence_receipt_ids: vec![],
|
|
},
|
|
);
|
|
value
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn approved_fission_commits_one_typed_lineage_batch_and_no_parallel_writer() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let store = CampaignStore::open(dir.path().join("campaign.cc")).unwrap();
|
|
let seed = hierarchical_refugee_campaign();
|
|
let parent = seed.gestalts["refugees-east"].clone();
|
|
let child = |id: &str, name: &str| GestaltPersonaState {
|
|
schema: "ghostlight.gestalt_persona_state.v1".into(),
|
|
id: id.into(),
|
|
name: name.into(),
|
|
version: 0,
|
|
home_location_id: parent.home_location_id.clone(),
|
|
shared_capabilities: parent.shared_capabilities.clone(),
|
|
shared_knowledge: parent.shared_knowledge.clone(),
|
|
resources: BTreeSet::new(),
|
|
goals: parent.goals.clone(),
|
|
pressures: parent.pressures.clone(),
|
|
};
|
|
let preview = GestaltFissionPreview {
|
|
schema: "ghostlight.gestalt_fission_preview.v1".into(),
|
|
campaign_id: seed.id,
|
|
expected_world_revision: seed.revision,
|
|
parent_gestalt_id: parent.id.clone(),
|
|
partition_axis: AgencyAxis::Ideology,
|
|
children: vec![
|
|
child("refugees-returning", "Refugees planning to return"),
|
|
child("refugees-other", "Other eastern transit refugees"),
|
|
],
|
|
child_partition_values: BTreeMap::from([
|
|
("refugees-returning".into(), "returning".into()),
|
|
("refugees-other".into(), "other/unknown".into()),
|
|
]),
|
|
residual_child_id: "refugees-other".into(),
|
|
member_child_assignments: BTreeMap::from([(
|
|
"mira".into(),
|
|
"refugees-returning".into(),
|
|
)]),
|
|
resource_child_assignments: BTreeMap::new(),
|
|
evidence_receipt_ids: vec![],
|
|
gaps: vec![],
|
|
canon_candidates: vec![],
|
|
requires_approval: true,
|
|
};
|
|
let kernel = WorldKernel::start(store.clone());
|
|
kernel
|
|
.command(WorldCommand::CreateCampaign {
|
|
campaign: seed.clone(),
|
|
evidence_receipts: vec![],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let result = kernel
|
|
.command(WorldCommand::FissionGestalt {
|
|
expected_revision: seed.revision,
|
|
preview,
|
|
evidence_receipts: vec![],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let CommandResult::Committed { campaign, receipt } = result else {
|
|
panic!("fission did not commit")
|
|
};
|
|
assert_eq!(receipt.command_kind, "fission_gestalt");
|
|
assert_eq!(campaign.revision, seed.revision + 1);
|
|
assert_eq!(campaign.gestalt_members["mira"].id, "mira");
|
|
assert_eq!(
|
|
campaign.gestalt_members["mira"].gestalt_id,
|
|
"refugees-returning"
|
|
);
|
|
assert!(!campaign.agency_profiles["refugees-east"].active_leaf);
|
|
assert!(campaign.agency_profiles["refugees-returning"].active_leaf);
|
|
assert_eq!(
|
|
store.keys("mutation_authority_envelope.v1").unwrap().len(),
|
|
1
|
|
);
|
|
assert_eq!(store.keys("world_mutation_batch.v1").unwrap().len(), 1);
|
|
assert_eq!(store.keys("world_mutation_receipt.v1").unwrap().len(), 1);
|
|
let batch = store
|
|
.load_all::<crate::transition::WorldMutationBatch>("world_mutation_batch.v1")
|
|
.unwrap()
|
|
.pop()
|
|
.unwrap();
|
|
let operations = batch
|
|
.mutations
|
|
.iter()
|
|
.map(|mutation| mutation.mutation.operation())
|
|
.collect::<BTreeSet<_>>();
|
|
assert!(operations.contains(&crate::transition::WorldMutationOperation::AdmitEntity));
|
|
assert!(operations.contains(&crate::transition::WorldMutationOperation::PopulationSplit));
|
|
assert!(
|
|
operations.contains(&crate::transition::WorldMutationOperation::PopulationTransfer)
|
|
);
|
|
assert!(!operations.contains(&crate::transition::WorldMutationOperation::ResourceCreate));
|
|
}
|
|
|
|
#[test]
|
|
fn member_migration_rebases_across_unrelated_hierarchy_without_changing_the_person() {
|
|
let mut value = hierarchical_refugee_campaign();
|
|
let capabilities_before =
|
|
crate::resolution::effective_member_capabilities(&value, "mira").unwrap();
|
|
let knowledge_before =
|
|
crate::resolution::effective_member_knowledge(&value, "mira").unwrap();
|
|
let identity_before = value.gestalt_members["mira"].clone();
|
|
let events = apply_strategic_tick_plan(
|
|
&mut value,
|
|
StrategicTickPlan {
|
|
member_migrations: vec![StrategicMemberMigration {
|
|
member_id: "mira".into(),
|
|
source_gestalt_id: "refugees-east".into(),
|
|
destination_gestalt_id: "dock-neighbors".into(),
|
|
destination_location_id: "docks".into(),
|
|
public_channels: vec![],
|
|
}],
|
|
..Default::default()
|
|
},
|
|
)
|
|
.unwrap();
|
|
let member = &value.gestalt_members["mira"];
|
|
assert_eq!(member.gestalt_id, "dock-neighbors");
|
|
assert_eq!(member.last_location_id.as_deref(), Some("docks"));
|
|
assert_eq!(member.version, identity_before.version + 1);
|
|
assert_eq!(member.name, identity_before.name);
|
|
assert_eq!(member.relationships, identity_before.relationships);
|
|
assert_eq!(member.memories, identity_before.memories);
|
|
assert_eq!(member.equipment, identity_before.equipment);
|
|
assert_eq!(member.conditions, identity_before.conditions);
|
|
assert_eq!(member.obligations, identity_before.obligations);
|
|
assert_eq!(member.goals, vec!["find safety"]);
|
|
assert_eq!(
|
|
crate::resolution::effective_member_capabilities(&value, "mira").unwrap(),
|
|
capabilities_before
|
|
);
|
|
assert_eq!(
|
|
crate::resolution::effective_member_knowledge(&value, "mira").unwrap(),
|
|
knowledge_before
|
|
);
|
|
assert_eq!(events.len(), 1);
|
|
assert_eq!(events[0].kind, "gestalt_member_migration");
|
|
assert_eq!(events[0].actor_ids, vec!["member:mira"]);
|
|
assert_eq!(
|
|
events[0].summary,
|
|
"Mira Venn moves from Transit camp to South docks and joins South dock neighbors."
|
|
);
|
|
|
|
let actor = materialize_actor(
|
|
&value.gestalts["dock-neighbors"],
|
|
member,
|
|
"member:mira",
|
|
"docks",
|
|
);
|
|
assert_eq!(actor.name, "Mira Venn");
|
|
assert_eq!(actor.capabilities, capabilities_before);
|
|
assert_eq!(actor.knowledge, knowledge_before);
|
|
assert_eq!(actor.relationships, identity_before.relationships);
|
|
assert_eq!(actor.memories, identity_before.memories);
|
|
}
|
|
|
|
#[test]
|
|
fn diaspora_distributes_people_across_nested_population_branches_without_merging_identity() {
|
|
let mut value = hierarchical_refugee_campaign();
|
|
value.locations.get_mut("camp").unwrap().routes.insert(
|
|
"to-hills".into(),
|
|
Route {
|
|
destination_id: "hills".into(),
|
|
distance: "along the ridge road".into(),
|
|
travel_minutes: 120,
|
|
},
|
|
);
|
|
value.locations.insert(
|
|
"hills".into(),
|
|
Location {
|
|
id: "hills".into(),
|
|
name: "North hills".into(),
|
|
container_id: None,
|
|
routes: BTreeMap::new(),
|
|
persistent_features: vec!["terraced gardens".into()],
|
|
},
|
|
);
|
|
|
|
let population = |id: &str, name: &str, location: &str| GestaltPersonaState {
|
|
schema: "ghostlight.gestalt_persona_state.v1".into(),
|
|
id: id.into(),
|
|
name: name.into(),
|
|
version: 0,
|
|
home_location_id: location.into(),
|
|
shared_capabilities: BTreeSet::from([format!("live among {name}")]),
|
|
shared_knowledge: BTreeSet::from([format!("routines of {name}")]),
|
|
resources: BTreeSet::new(),
|
|
goals: vec![format!("sustain {name}")],
|
|
pressures: vec![],
|
|
};
|
|
for (id, name, location) in [
|
|
("displaced-root", "Displaced people", "camp"),
|
|
("crisis-refugees", "Crisis refugees", "camp"),
|
|
("displaced-other", "Other displaced people", "camp"),
|
|
("crisis-other", "Other crisis refugees", "camp"),
|
|
("southport-root", "Southport residents", "docks"),
|
|
("harbor-populations", "Harbor populations", "docks"),
|
|
("harbor-other", "Other harbor residents", "docks"),
|
|
("inland-other", "Inland residents", "hills"),
|
|
("hill-neighbors", "North hill neighbors", "hills"),
|
|
("inland-unknown", "Other inland residents", "hills"),
|
|
] {
|
|
value
|
|
.gestalts
|
|
.insert(id.into(), population(id, name, location));
|
|
}
|
|
crate::resolution::ensure_agency_profiles(&mut value);
|
|
|
|
for parent_id in [
|
|
"displaced-root",
|
|
"crisis-refugees",
|
|
"southport-root",
|
|
"harbor-populations",
|
|
"inland-other",
|
|
] {
|
|
let profile = value.agency_profiles.get_mut(parent_id).unwrap();
|
|
profile.active_leaf = false;
|
|
profile.simulation_eligible = false;
|
|
}
|
|
for (child_id, parent_id) in [
|
|
("crisis-refugees", "displaced-root"),
|
|
("displaced-other", "displaced-root"),
|
|
("refugees-east", "crisis-refugees"),
|
|
("crisis-other", "crisis-refugees"),
|
|
("harbor-populations", "southport-root"),
|
|
("inland-other", "southport-root"),
|
|
("dock-neighbors", "harbor-populations"),
|
|
("harbor-other", "harbor-populations"),
|
|
("hill-neighbors", "inland-other"),
|
|
("inland-unknown", "inland-other"),
|
|
] {
|
|
value
|
|
.agency_profiles
|
|
.get_mut(child_id)
|
|
.unwrap()
|
|
.parent_subject_id = Some(parent_id.into());
|
|
}
|
|
let lineage =
|
|
|parent: &str, children: [&str; 2], residual: &str, axis: AgencyAxis| GestaltLineage {
|
|
schema: "ghostlight.gestalt_lineage.v1".into(),
|
|
parent_gestalt_id: parent.into(),
|
|
child_gestalt_ids: children.iter().map(|id| (*id).into()).collect(),
|
|
partition_axis: axis,
|
|
partition_values: BTreeMap::from([
|
|
(children[0].into(), "selected".into()),
|
|
(children[1].into(), "other/unknown".into()),
|
|
]),
|
|
residual_child_id: residual.into(),
|
|
source_revision: value.revision,
|
|
};
|
|
value.gestalt_lineages.insert(
|
|
"displaced-root".into(),
|
|
lineage(
|
|
"displaced-root",
|
|
["crisis-refugees", "displaced-other"],
|
|
"displaced-other",
|
|
AgencyAxis::Ideology,
|
|
),
|
|
);
|
|
value.gestalt_lineages.insert(
|
|
"crisis-refugees".into(),
|
|
lineage(
|
|
"crisis-refugees",
|
|
["refugees-east", "crisis-other"],
|
|
"crisis-other",
|
|
AgencyAxis::Geography,
|
|
),
|
|
);
|
|
value.gestalt_lineages.insert(
|
|
"southport-root".into(),
|
|
lineage(
|
|
"southport-root",
|
|
["harbor-populations", "inland-other"],
|
|
"inland-other",
|
|
AgencyAxis::Geography,
|
|
),
|
|
);
|
|
value.gestalt_lineages.insert(
|
|
"harbor-populations".into(),
|
|
lineage(
|
|
"harbor-populations",
|
|
["dock-neighbors", "harbor-other"],
|
|
"harbor-other",
|
|
AgencyAxis::EconomyRole,
|
|
),
|
|
);
|
|
value.gestalt_lineages.insert(
|
|
"inland-other".into(),
|
|
lineage(
|
|
"inland-other",
|
|
["hill-neighbors", "inland-unknown"],
|
|
"inland-unknown",
|
|
AgencyAxis::Authority,
|
|
),
|
|
);
|
|
|
|
let mut tovan = value.gestalt_members["mira"].clone();
|
|
tovan.id = "tovan".into();
|
|
tovan.name = "Tovan Ser".into();
|
|
tovan.version = 9;
|
|
tovan.capability_additions = BTreeSet::from(["tend terrace herbs".into()]);
|
|
tovan.knowledge_additions = BTreeSet::from(["the player found his daughter".into()]);
|
|
tovan.equipment = BTreeSet::from(["copper seed case".into()]);
|
|
tovan.conditions = BTreeSet::from(["healed broken wrist".into()]);
|
|
tovan.obligations = BTreeSet::from(["send medicine back to the camp".into()]);
|
|
tovan.relationships = BTreeMap::from([(
|
|
"player".into(),
|
|
"remembers that they found his daughter".into(),
|
|
)]);
|
|
tovan.memories = vec!["The player found Lio beneath the fallen awning.".into()];
|
|
value.gestalt_members.insert("tovan".into(), tovan);
|
|
value.agency_relations.insert(
|
|
"hill-resettlement".into(),
|
|
AgencyRelation {
|
|
schema: "ghostlight.agency_relation.v1".into(),
|
|
id: "hill-resettlement".into(),
|
|
from_subject_id: "refugees-east".into(),
|
|
to_subject_id: "hill-neighbors".into(),
|
|
kind: AgencyRelationKind::Migration,
|
|
strength: 85,
|
|
active: true,
|
|
evidence_receipt_ids: vec![],
|
|
},
|
|
);
|
|
|
|
let before = value.gestalt_members.clone();
|
|
let source_before = value.gestalts["refugees-east"].clone();
|
|
let docks_before = value.gestalts["dock-neighbors"].clone();
|
|
let hills_before = value.gestalts["hill-neighbors"].clone();
|
|
let effective_goals = |campaign: &Campaign, id: &str| {
|
|
let member = &campaign.gestalt_members[id];
|
|
if member.goals.is_empty() {
|
|
campaign.gestalts[&member.gestalt_id]
|
|
.goals
|
|
.iter()
|
|
.cloned()
|
|
.collect::<BTreeSet<_>>()
|
|
} else {
|
|
member.goals.iter().cloned().collect::<BTreeSet<_>>()
|
|
}
|
|
};
|
|
let effective_before = ["mira", "tovan"]
|
|
.into_iter()
|
|
.map(|id| {
|
|
(
|
|
id,
|
|
(
|
|
crate::resolution::effective_member_capabilities(&value, id).unwrap(),
|
|
crate::resolution::effective_member_knowledge(&value, id).unwrap(),
|
|
effective_goals(&value, id),
|
|
),
|
|
)
|
|
})
|
|
.collect::<BTreeMap<_, _>>();
|
|
|
|
let events = apply_strategic_tick_plan(
|
|
&mut value,
|
|
StrategicTickPlan {
|
|
member_migrations: vec![
|
|
StrategicMemberMigration {
|
|
member_id: "mira".into(),
|
|
source_gestalt_id: "refugees-east".into(),
|
|
destination_gestalt_id: "dock-neighbors".into(),
|
|
destination_location_id: "docks".into(),
|
|
public_channels: vec![],
|
|
},
|
|
StrategicMemberMigration {
|
|
member_id: "tovan".into(),
|
|
source_gestalt_id: "refugees-east".into(),
|
|
destination_gestalt_id: "hill-neighbors".into(),
|
|
destination_location_id: "hills".into(),
|
|
public_channels: vec![],
|
|
},
|
|
],
|
|
..Default::default()
|
|
},
|
|
)
|
|
.unwrap();
|
|
|
|
for (id, destination, location) in [
|
|
("mira", "dock-neighbors", "docks"),
|
|
("tovan", "hill-neighbors", "hills"),
|
|
] {
|
|
let member = &value.gestalt_members[id];
|
|
let old = &before[id];
|
|
assert_eq!(member.id, old.id);
|
|
assert_eq!(member.name, old.name);
|
|
assert_eq!(member.gestalt_id, destination);
|
|
assert_eq!(member.last_location_id.as_deref(), Some(location));
|
|
assert_eq!(member.version, old.version + 1);
|
|
assert_eq!(member.relationships, old.relationships);
|
|
assert_eq!(member.memories, old.memories);
|
|
assert_eq!(member.equipment, old.equipment);
|
|
assert_eq!(member.conditions, old.conditions);
|
|
assert_eq!(member.obligations, old.obligations);
|
|
assert_eq!(
|
|
crate::resolution::effective_member_capabilities(&value, id).unwrap(),
|
|
effective_before[id].0
|
|
);
|
|
assert_eq!(
|
|
crate::resolution::effective_member_knowledge(&value, id).unwrap(),
|
|
effective_before[id].1
|
|
);
|
|
assert_eq!(effective_goals(&value, id), effective_before[id].2);
|
|
let actor = materialize_actor(
|
|
&value.gestalts[destination],
|
|
member,
|
|
&crate::domain::gestalt_member_subject_id(id),
|
|
location,
|
|
);
|
|
assert_eq!(actor.name, old.name);
|
|
assert_eq!(actor.relationships, old.relationships);
|
|
assert_eq!(actor.memories, old.memories);
|
|
}
|
|
for (id, before, version_increment) in [
|
|
("refugees-east", source_before, 1),
|
|
("dock-neighbors", docks_before, 1),
|
|
("hill-neighbors", hills_before, 1),
|
|
] {
|
|
let after = &value.gestalts[id];
|
|
assert_eq!(after.name, before.name);
|
|
assert_eq!(after.home_location_id, before.home_location_id);
|
|
assert_eq!(after.shared_capabilities, before.shared_capabilities);
|
|
assert_eq!(after.shared_knowledge, before.shared_knowledge);
|
|
assert_eq!(after.resources, before.resources);
|
|
assert_eq!(after.goals, before.goals);
|
|
assert_eq!(after.pressures, before.pressures);
|
|
assert_eq!(after.version, before.version + version_increment);
|
|
}
|
|
assert_eq!(events.len(), 2);
|
|
assert_eq!(events[0].actor_ids, vec!["member:mira"]);
|
|
assert_eq!(events[1].actor_ids, vec!["member:tovan"]);
|
|
assert_eq!(
|
|
events[0].gestalt_ids,
|
|
vec!["refugees-east", "dock-neighbors"]
|
|
);
|
|
assert_eq!(
|
|
events[1].gestalt_ids,
|
|
vec!["refugees-east", "hill-neighbors"]
|
|
);
|
|
|
|
let depth = |leaf_id: &str| {
|
|
let mut current = leaf_id;
|
|
let mut depth = 0;
|
|
while let Some(lineage) = value.gestalt_lineages.values().find(|lineage| {
|
|
lineage
|
|
.child_gestalt_ids
|
|
.iter()
|
|
.any(|child| child == current)
|
|
}) {
|
|
depth += 1;
|
|
current = &lineage.parent_gestalt_id;
|
|
}
|
|
depth
|
|
};
|
|
assert_eq!(depth("refugees-east"), 2);
|
|
assert_eq!(depth("dock-neighbors"), 2);
|
|
assert_eq!(depth("hill-neighbors"), 2);
|
|
}
|
|
|
|
#[test]
|
|
fn gestalt_migration_moves_only_the_population_leaf() {
|
|
let mut value = hierarchical_refugee_campaign();
|
|
let member_before = value.gestalt_members["mira"].clone();
|
|
let destination_before = value.gestalts["dock-neighbors"].clone();
|
|
let events = apply_strategic_tick_plan(
|
|
&mut value,
|
|
StrategicTickPlan {
|
|
gestalt_migrations: vec![StrategicGestaltMigration {
|
|
gestalt_id: "refugees-east".into(),
|
|
destination_gestalt_id: "dock-neighbors".into(),
|
|
destination_location_id: "docks".into(),
|
|
public_channels: vec!["camp-bulletin".into()],
|
|
}],
|
|
..Default::default()
|
|
},
|
|
)
|
|
.unwrap();
|
|
|
|
assert_eq!(value.gestalts["refugees-east"].home_location_id, "docks");
|
|
assert_eq!(value.gestalts["refugees-east"].version, 1);
|
|
assert_eq!(
|
|
value.agency_profiles["refugees-east"].location_ids,
|
|
BTreeSet::from(["docks".into()])
|
|
);
|
|
assert_eq!(value.gestalt_members["mira"], member_before);
|
|
assert_eq!(value.gestalts["dock-neighbors"], destination_before);
|
|
assert_eq!(events.len(), 1);
|
|
assert_eq!(events[0].kind, "gestalt_migration");
|
|
assert_eq!(
|
|
events[0].summary,
|
|
"Eastern transit refugees relocates from Transit camp to South docks near South dock neighbors."
|
|
);
|
|
assert!(!events[0].summary.contains("refugees-east"));
|
|
assert!(!events[0].summary.contains("dock-neighbors"));
|
|
assert_eq!(events[0].location_ids, vec!["camp", "docks"]);
|
|
assert_eq!(
|
|
events[0].gestalt_ids,
|
|
vec!["refugees-east", "dock-neighbors"]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn simultaneous_migration_preserves_snapshot_scoped_activity() {
|
|
let mut value = hierarchical_refugee_campaign();
|
|
value.gestalts.insert(
|
|
"camp-neighbors".into(),
|
|
GestaltPersonaState {
|
|
schema: "ghostlight.gestalt_persona_state.v1".into(),
|
|
id: "camp-neighbors".into(),
|
|
name: "Camp neighbors".into(),
|
|
version: 0,
|
|
home_location_id: "camp".into(),
|
|
shared_capabilities: BTreeSet::from(["raise signal fires".into()]),
|
|
shared_knowledge: BTreeSet::new(),
|
|
resources: BTreeSet::new(),
|
|
goals: vec!["keep departures visible".into()],
|
|
pressures: vec![],
|
|
},
|
|
);
|
|
crate::resolution::ensure_agency_profiles(&mut value);
|
|
|
|
let events = apply_strategic_tick_plan(
|
|
&mut value,
|
|
resolve_test_activities(StrategicTickPlan {
|
|
gestalt_migrations: vec![StrategicGestaltMigration {
|
|
gestalt_id: "refugees-east".into(),
|
|
destination_gestalt_id: "dock-neighbors".into(),
|
|
destination_location_id: "docks".into(),
|
|
public_channels: vec![],
|
|
}],
|
|
gestalt_activities: vec![StrategicGestaltActivity {
|
|
action_digest: test_action_digest("simultaneous communication"),
|
|
gestalt_id: "camp-neighbors".into(),
|
|
activity: StrategicActivityKind::Communicate,
|
|
target_subject_ids: vec!["refugees-east".into()],
|
|
location_ids: vec!["camp".into()],
|
|
public_channels: vec![],
|
|
}],
|
|
..Default::default()
|
|
}),
|
|
)
|
|
.unwrap();
|
|
|
|
assert_eq!(value.gestalts["refugees-east"].home_location_id, "docks");
|
|
assert_eq!(events.len(), 2);
|
|
assert_eq!(events[1].kind, "gestalt_activity");
|
|
assert_eq!(events[1].location_ids, vec!["camp"]);
|
|
assert_eq!(
|
|
events[1].summary,
|
|
"Camp neighbors sends a communication to Eastern transit refugees."
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn cohesive_gestalt_internal_coordination_reaches_canonical_and_legacy_commit_paths() {
|
|
let action = CellActionProposal {
|
|
subject_id: "refugees-east".into(),
|
|
intent: "coordinate the households' own water watch".into(),
|
|
intended_effect:
|
|
"coordinate internal water-watch shifts without naming an external party".into(),
|
|
priority: 80,
|
|
state_references: vec![],
|
|
public_channels: vec![],
|
|
effects: vec![StrategicCellEffect::GestaltActivity {
|
|
gestalt_id: "refugees-east".into(),
|
|
activity: StrategicActivityKind::Coordinate,
|
|
target_subject_ids: vec![],
|
|
location_ids: vec!["camp".into()],
|
|
}],
|
|
};
|
|
let action_digest = crate::resolution::cell_action_digest(&action).unwrap();
|
|
let mut canonical = hierarchical_refugee_campaign();
|
|
let canonical_events = apply_strategic_tick_plan(
|
|
&mut canonical,
|
|
StrategicTickPlan {
|
|
selected_actions: vec![action],
|
|
activity_outcomes: vec![StrategicActivityOutcome {
|
|
schema: "ghostlight.strategic_activity_outcome.v1".into(),
|
|
action_digest,
|
|
source_subject_id: "refugees-east".into(),
|
|
band: StrategicOutcomeBand::Mixed,
|
|
summary: "The households arrange the watch; its efficacy remains unsettled."
|
|
.into(),
|
|
supporting_state_references: vec![],
|
|
effect: StrategicOutcomeEffect::NoMaterialChange {
|
|
reason: "No external response or durable result is established.".into(),
|
|
},
|
|
}],
|
|
..Default::default()
|
|
},
|
|
)
|
|
.unwrap();
|
|
assert_eq!(canonical_events.len(), 1);
|
|
assert_eq!(canonical_events[0].kind, "gestalt_activity");
|
|
assert!(
|
|
canonical_events[0]
|
|
.summary
|
|
.contains("internal water-watch shifts")
|
|
);
|
|
|
|
let mut legacy = hierarchical_refugee_campaign();
|
|
let legacy_events = apply_strategic_tick_plan(
|
|
&mut legacy,
|
|
resolve_test_activities(StrategicTickPlan {
|
|
gestalt_activities: vec![StrategicGestaltActivity {
|
|
action_digest: test_action_digest("internal water-watch coordination"),
|
|
gestalt_id: "refugees-east".into(),
|
|
activity: StrategicActivityKind::Coordinate,
|
|
target_subject_ids: vec![],
|
|
location_ids: vec!["camp".into()],
|
|
public_channels: vec![],
|
|
}],
|
|
..Default::default()
|
|
}),
|
|
)
|
|
.unwrap();
|
|
assert_eq!(legacy_events.len(), 1);
|
|
assert_eq!(
|
|
legacy_events[0].summary,
|
|
"Eastern transit refugees attempts internal coordination."
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn institution_posture_uses_the_canonical_character_bound_at_commit() {
|
|
let mut value = campaign();
|
|
value.institutions.insert(
|
|
"board".into(),
|
|
InstitutionState {
|
|
id: "board".into(),
|
|
name: "Board".into(),
|
|
resources: vec![],
|
|
goals: vec![],
|
|
posture: "watching".into(),
|
|
},
|
|
);
|
|
crate::resolution::ensure_agency_profiles(&mut value);
|
|
let events = apply_strategic_tick_plan(
|
|
&mut value,
|
|
StrategicTickPlan {
|
|
institution_actions: vec![StrategicInstitutionAction {
|
|
institution_id: "board".into(),
|
|
posture: "x".repeat(MAX_POSTURE_CHARS),
|
|
location_ids: vec![],
|
|
public_channels: vec![],
|
|
}],
|
|
..Default::default()
|
|
},
|
|
)
|
|
.unwrap();
|
|
assert_eq!(events.len(), 1);
|
|
assert!(
|
|
events[0]
|
|
.summary
|
|
.starts_with("Board announces a new course: ")
|
|
);
|
|
assert!(!events[0].summary.contains("adopts posture"));
|
|
assert_eq!(
|
|
value.institutions["board"].posture.chars().count(),
|
|
MAX_POSTURE_CHARS
|
|
);
|
|
|
|
let before_oversized = value.clone();
|
|
assert!(
|
|
apply_strategic_tick_plan(
|
|
&mut value,
|
|
StrategicTickPlan {
|
|
institution_actions: vec![StrategicInstitutionAction {
|
|
institution_id: "board".into(),
|
|
posture: "y".repeat(MAX_POSTURE_CHARS + 1),
|
|
location_ids: vec![],
|
|
public_channels: vec![],
|
|
}],
|
|
..Default::default()
|
|
},
|
|
)
|
|
.is_err()
|
|
);
|
|
assert_eq!(value, before_oversized);
|
|
}
|
|
|
|
#[test]
|
|
fn canonical_action_commits_distinct_scopes_of_one_activity_kind() {
|
|
let mut value = hierarchical_refugee_campaign();
|
|
let targeted = StrategicCellEffect::GestaltActivity {
|
|
gestalt_id: "refugees-east".into(),
|
|
activity: StrategicActivityKind::Communicate,
|
|
target_subject_ids: vec!["dock-neighbors".into()],
|
|
location_ids: vec!["camp".into()],
|
|
};
|
|
let local = StrategicCellEffect::GestaltActivity {
|
|
gestalt_id: "refugees-east".into(),
|
|
activity: StrategicActivityKind::Communicate,
|
|
target_subject_ids: vec![],
|
|
location_ids: vec!["camp".into()],
|
|
};
|
|
let action = CellActionProposal {
|
|
subject_id: "refugees-east".into(),
|
|
intent: "Warn the dock neighbors and the unnamed camp assembly.".into(),
|
|
intended_effect: "Send both warnings without merging their audiences.".into(),
|
|
priority: 80,
|
|
state_references: vec![],
|
|
public_channels: vec![],
|
|
effects: vec![targeted.clone(), local],
|
|
};
|
|
let action_digest = crate::resolution::cell_action_digest(&action).unwrap();
|
|
let events = apply_strategic_tick_plan(
|
|
&mut value,
|
|
StrategicTickPlan {
|
|
selected_actions: vec![action],
|
|
activity_outcomes: vec![StrategicActivityOutcome {
|
|
schema: "ghostlight.strategic_activity_outcome.v1".into(),
|
|
action_digest,
|
|
source_subject_id: "refugees-east".into(),
|
|
band: StrategicOutcomeBand::Mixed,
|
|
summary: "The warnings are sent; their reception remains unsettled.".into(),
|
|
supporting_state_references: vec![],
|
|
effect: StrategicOutcomeEffect::NoMaterialChange {
|
|
reason: "No response is established in this test snapshot.".into(),
|
|
},
|
|
}],
|
|
..Default::default()
|
|
},
|
|
)
|
|
.unwrap();
|
|
|
|
assert_eq!(events.len(), 2);
|
|
assert!(events.iter().all(|event| event.kind == "gestalt_activity"));
|
|
assert_eq!(
|
|
events
|
|
.iter()
|
|
.map(|event| event.id.as_str())
|
|
.collect::<BTreeSet<_>>()
|
|
.len(),
|
|
2
|
|
);
|
|
|
|
let before_duplicate = value.clone();
|
|
let duplicate = CellActionProposal {
|
|
subject_id: "refugees-east".into(),
|
|
intent: "Repeat one exact warning twice.".into(),
|
|
intended_effect: "Send the same warning twice.".into(),
|
|
priority: 80,
|
|
state_references: vec![],
|
|
public_channels: vec![],
|
|
effects: vec![targeted.clone(), targeted],
|
|
};
|
|
let duplicate_digest = crate::resolution::cell_action_digest(&duplicate).unwrap();
|
|
let error = apply_strategic_tick_plan(
|
|
&mut value,
|
|
StrategicTickPlan {
|
|
selected_actions: vec![duplicate],
|
|
activity_outcomes: vec![StrategicActivityOutcome {
|
|
schema: "ghostlight.strategic_activity_outcome.v1".into(),
|
|
action_digest: duplicate_digest,
|
|
source_subject_id: "refugees-east".into(),
|
|
band: StrategicOutcomeBand::Mixed,
|
|
summary: "The repeated warning has no separate durable result.".into(),
|
|
supporting_state_references: vec![],
|
|
effect: StrategicOutcomeEffect::NoMaterialChange {
|
|
reason: "No distinct response is established.".into(),
|
|
},
|
|
}],
|
|
..Default::default()
|
|
},
|
|
)
|
|
.unwrap_err();
|
|
assert!(error.to_string().contains("acts twice"), "{error}");
|
|
assert_eq!(value, before_duplicate);
|
|
|
|
let aliased = CellActionProposal {
|
|
subject_id: "refugees-east".into(),
|
|
intent: "Repeat one local warning through aliased location syntax.".into(),
|
|
intended_effect: "Send one local warning.".into(),
|
|
priority: 80,
|
|
state_references: vec![],
|
|
public_channels: vec![],
|
|
effects: vec![
|
|
StrategicCellEffect::GestaltActivity {
|
|
gestalt_id: "refugees-east".into(),
|
|
activity: StrategicActivityKind::Communicate,
|
|
target_subject_ids: vec![],
|
|
location_ids: vec![],
|
|
},
|
|
StrategicCellEffect::GestaltActivity {
|
|
gestalt_id: "refugees-east".into(),
|
|
activity: StrategicActivityKind::Communicate,
|
|
target_subject_ids: vec![],
|
|
location_ids: vec!["camp".into()],
|
|
},
|
|
],
|
|
};
|
|
let aliased_digest = crate::resolution::cell_action_digest(&aliased).unwrap();
|
|
let error = apply_strategic_tick_plan(
|
|
&mut value,
|
|
StrategicTickPlan {
|
|
selected_actions: vec![aliased],
|
|
activity_outcomes: vec![StrategicActivityOutcome {
|
|
schema: "ghostlight.strategic_activity_outcome.v1".into(),
|
|
action_digest: aliased_digest,
|
|
source_subject_id: "refugees-east".into(),
|
|
band: StrategicOutcomeBand::Mixed,
|
|
summary: "The local warning has no separate durable result.".into(),
|
|
supporting_state_references: vec![],
|
|
effect: StrategicOutcomeEffect::NoMaterialChange {
|
|
reason: "No distinct response is established.".into(),
|
|
},
|
|
}],
|
|
..Default::default()
|
|
},
|
|
)
|
|
.unwrap_err();
|
|
assert!(error.to_string().contains("acts twice"), "{error}");
|
|
assert_eq!(value, before_duplicate);
|
|
}
|
|
|
|
#[test]
|
|
fn invalid_late_strategic_action_cannot_partially_apply_an_earlier_action() {
|
|
let mut value = hierarchical_refugee_campaign();
|
|
let before = value.clone();
|
|
let error = apply_strategic_tick_plan(
|
|
&mut value,
|
|
resolve_test_activities(StrategicTickPlan {
|
|
gestalt_migrations: vec![StrategicGestaltMigration {
|
|
gestalt_id: "refugees-east".into(),
|
|
destination_gestalt_id: "dock-neighbors".into(),
|
|
destination_location_id: "docks".into(),
|
|
public_channels: vec![],
|
|
}],
|
|
gestalt_activities: vec![StrategicGestaltActivity {
|
|
action_digest: test_action_digest("conflicting refugee preparation"),
|
|
gestalt_id: "refugees-east".into(),
|
|
activity: StrategicActivityKind::Prepare,
|
|
target_subject_ids: vec![],
|
|
location_ids: vec!["camp".into()],
|
|
public_channels: vec![],
|
|
}],
|
|
..Default::default()
|
|
}),
|
|
)
|
|
.unwrap_err();
|
|
|
|
assert!(error.to_string().contains("acts twice"));
|
|
assert_eq!(value, before);
|
|
}
|
|
|
|
#[test]
|
|
fn population_cannot_move_without_its_exact_migration_relation() {
|
|
let mut value = hierarchical_refugee_campaign();
|
|
value.agency_relations.clear();
|
|
let before = value.clone();
|
|
let error = apply_strategic_tick_plan(
|
|
&mut value,
|
|
StrategicTickPlan {
|
|
gestalt_migrations: vec![StrategicGestaltMigration {
|
|
gestalt_id: "refugees-east".into(),
|
|
destination_gestalt_id: "dock-neighbors".into(),
|
|
destination_location_id: "docks".into(),
|
|
public_channels: vec![],
|
|
}],
|
|
..Default::default()
|
|
},
|
|
)
|
|
.unwrap_err();
|
|
assert!(error.to_string().contains("source-to-destination relation"));
|
|
assert_eq!(value, before);
|
|
}
|
|
|
|
#[test]
|
|
fn invalid_population_migration_batch_has_no_partial_move() {
|
|
let mut value = hierarchical_refugee_campaign();
|
|
let before = value.clone();
|
|
let action = StrategicGestaltMigration {
|
|
gestalt_id: "refugees-east".into(),
|
|
destination_gestalt_id: "dock-neighbors".into(),
|
|
destination_location_id: "docks".into(),
|
|
public_channels: vec![],
|
|
};
|
|
let error = apply_strategic_tick_plan(
|
|
&mut value,
|
|
StrategicTickPlan {
|
|
gestalt_migrations: vec![action.clone(), action],
|
|
..Default::default()
|
|
},
|
|
)
|
|
.unwrap_err();
|
|
assert!(error.to_string().contains("acts twice"));
|
|
assert_eq!(value, before);
|
|
}
|
|
|
|
#[test]
|
|
fn member_migration_requires_the_persons_route_and_typed_population_relation() {
|
|
let mut value = hierarchical_refugee_campaign();
|
|
value.agency_relations.clear();
|
|
let before = value.clone();
|
|
let error = apply_strategic_tick_plan(
|
|
&mut value,
|
|
StrategicTickPlan {
|
|
member_migrations: vec![StrategicMemberMigration {
|
|
member_id: "mira".into(),
|
|
source_gestalt_id: "refugees-east".into(),
|
|
destination_gestalt_id: "dock-neighbors".into(),
|
|
destination_location_id: "docks".into(),
|
|
public_channels: vec![],
|
|
}],
|
|
..Default::default()
|
|
},
|
|
)
|
|
.unwrap_err();
|
|
assert!(error.to_string().contains("migration relation"));
|
|
assert_eq!(value.gestalt_members, before.gestalt_members);
|
|
}
|
|
|
|
#[test]
|
|
fn gestalt_action_resolves_exact_pressure_and_records_only_the_typed_transition() {
|
|
let mut value = hierarchical_refugee_campaign();
|
|
value.gestalts.get_mut("refugees-east").unwrap().pressures =
|
|
vec!["the storm closes the camp".into()];
|
|
let events = apply_strategic_tick_plan(
|
|
&mut value,
|
|
StrategicTickPlan {
|
|
gestalt_actions: vec![StrategicGestaltAction {
|
|
gestalt_id: "refugees-east".into(),
|
|
pressure_additions: vec!["shelter assignments remain unsettled".into()],
|
|
pressure_resolutions: vec!["the storm closes the camp".into()],
|
|
public_channels: vec![],
|
|
}],
|
|
..Default::default()
|
|
},
|
|
)
|
|
.unwrap();
|
|
assert_eq!(
|
|
value.gestalts["refugees-east"].pressures,
|
|
vec!["shelter assignments remain unsettled"]
|
|
);
|
|
assert_eq!(value.gestalts["refugees-east"].version, 1);
|
|
assert_eq!(
|
|
events[0].summary,
|
|
"A declaration from Eastern transit refugees marks this matter settled: the storm closes the camp; New public demand from Eastern transit refugees: shelter assignments remain unsettled"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn gestalt_activity_requires_an_explicit_resolved_no_material_outcome() {
|
|
let mut value = hierarchical_refugee_campaign();
|
|
let before = value.clone();
|
|
let events = apply_strategic_tick_plan(
|
|
&mut value,
|
|
resolve_test_activities(StrategicTickPlan {
|
|
gestalt_activities: vec![StrategicGestaltActivity {
|
|
action_digest: test_action_digest("refugee coordination"),
|
|
gestalt_id: "refugees-east".into(),
|
|
activity: StrategicActivityKind::Coordinate,
|
|
target_subject_ids: vec!["dock-neighbors".into()],
|
|
location_ids: vec!["camp".into()],
|
|
public_channels: vec![],
|
|
}],
|
|
..Default::default()
|
|
}),
|
|
)
|
|
.unwrap();
|
|
assert_only_strategic_obligations_advanced(&before, &value);
|
|
assert_eq!(events.len(), 1);
|
|
assert_eq!(events[0].kind, "gestalt_activity");
|
|
assert_eq!(
|
|
events[0].summary,
|
|
"Eastern transit refugees attempts to coordinate with South dock neighbors."
|
|
);
|
|
assert_eq!(
|
|
events[0].gestalt_ids,
|
|
vec!["refugees-east", "dock-neighbors"]
|
|
);
|
|
assert!(events[0].actor_ids.is_empty());
|
|
assert!(events[0].institution_ids.is_empty());
|
|
assert!(
|
|
events
|
|
.iter()
|
|
.all(|event| event.kind != "strategic_activity_outcome")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn strategic_outcome_materializes_a_bounded_resource_from_exact_capability() {
|
|
let mut value = hierarchical_refugee_campaign();
|
|
let digest = test_action_digest("refugees prepare storm lashings");
|
|
let events = apply_strategic_tick_plan(
|
|
&mut value,
|
|
StrategicTickPlan {
|
|
gestalt_activities: vec![StrategicGestaltActivity {
|
|
action_digest: digest.clone(),
|
|
gestalt_id: "refugees-east".into(),
|
|
activity: StrategicActivityKind::Prepare,
|
|
target_subject_ids: vec![],
|
|
location_ids: vec!["camp".into()],
|
|
public_channels: vec![],
|
|
}],
|
|
activity_outcomes: vec![StrategicActivityOutcome {
|
|
schema: "ghostlight.strategic_activity_outcome.v1".into(),
|
|
action_digest: digest,
|
|
source_subject_id: "refugees-east".into(),
|
|
band: StrategicOutcomeBand::Success,
|
|
summary: "The refugees finish a set of storm lashings.".into(),
|
|
supporting_state_references: vec![
|
|
"capability:survive transit".into(),
|
|
"location:camp".into(),
|
|
],
|
|
effect: StrategicOutcomeEffect::ResourceCreated {
|
|
owner_subject_id: "refugees-east".into(),
|
|
resource: "storm lashings".into(),
|
|
},
|
|
}],
|
|
..Default::default()
|
|
},
|
|
)
|
|
.unwrap();
|
|
|
|
assert!(
|
|
value.gestalts["refugees-east"]
|
|
.resources
|
|
.contains("storm lashings")
|
|
);
|
|
assert_eq!(value.gestalts["refugees-east"].version, 1);
|
|
assert_eq!(events.len(), 2);
|
|
assert_eq!(events[1].kind, "strategic_activity_outcome");
|
|
}
|
|
|
|
#[test]
|
|
fn invalid_outcome_bundle_cannot_apply_an_earlier_material_effect() {
|
|
let mut value = hierarchical_refugee_campaign();
|
|
let before = value.clone();
|
|
let first = test_action_digest("valid material preparation");
|
|
let second = test_action_digest("invalid resource spend");
|
|
let error = apply_strategic_tick_plan(
|
|
&mut value,
|
|
StrategicTickPlan {
|
|
gestalt_activities: vec![
|
|
StrategicGestaltActivity {
|
|
action_digest: first.clone(),
|
|
gestalt_id: "refugees-east".into(),
|
|
activity: StrategicActivityKind::Prepare,
|
|
target_subject_ids: vec![],
|
|
location_ids: vec!["camp".into()],
|
|
public_channels: vec![],
|
|
},
|
|
StrategicGestaltActivity {
|
|
action_digest: second.clone(),
|
|
gestalt_id: "dock-neighbors".into(),
|
|
activity: StrategicActivityKind::Prepare,
|
|
target_subject_ids: vec![],
|
|
location_ids: vec!["docks".into()],
|
|
public_channels: vec![],
|
|
},
|
|
],
|
|
activity_outcomes: vec![
|
|
StrategicActivityOutcome {
|
|
schema: "ghostlight.strategic_activity_outcome.v1".into(),
|
|
action_digest: first,
|
|
source_subject_id: "refugees-east".into(),
|
|
band: StrategicOutcomeBand::Success,
|
|
summary: "A valid first result.".into(),
|
|
supporting_state_references: vec!["capability:survive transit".into()],
|
|
effect: StrategicOutcomeEffect::ResourceCreated {
|
|
owner_subject_id: "refugees-east".into(),
|
|
resource: "valid new shelter frame".into(),
|
|
},
|
|
},
|
|
StrategicActivityOutcome {
|
|
schema: "ghostlight.strategic_activity_outcome.v1".into(),
|
|
action_digest: second,
|
|
source_subject_id: "dock-neighbors".into(),
|
|
band: StrategicOutcomeBand::Failure,
|
|
summary: "An invalid second result.".into(),
|
|
supporting_state_references: vec!["capability:repair nets".into()],
|
|
effect: StrategicOutcomeEffect::ResourceConsumed {
|
|
owner_subject_id: "dock-neighbors".into(),
|
|
resource: "invented missing winch".into(),
|
|
},
|
|
},
|
|
],
|
|
..Default::default()
|
|
},
|
|
)
|
|
.unwrap_err();
|
|
|
|
assert!(error.to_string().contains("custody"));
|
|
assert_eq!(value, before);
|
|
}
|
|
|
|
#[test]
|
|
fn member_outcome_preserves_its_own_relationship_without_mutating_the_player() {
|
|
let mut value = hierarchical_refugee_campaign();
|
|
value.agency_relations.insert(
|
|
"refugee-message-to-player".into(),
|
|
AgencyRelation {
|
|
schema: "ghostlight.agency_relation.v1".into(),
|
|
id: "refugee-message-to-player".into(),
|
|
from_subject_id: "refugees-east".into(),
|
|
to_subject_id: "player".into(),
|
|
kind: AgencyRelationKind::Communication,
|
|
strength: 40,
|
|
active: true,
|
|
evidence_receipt_ids: vec![],
|
|
},
|
|
);
|
|
let player_before = value.actors["player"].clone();
|
|
let digest = test_action_digest("mira renews her promise");
|
|
apply_strategic_tick_plan(
|
|
&mut value,
|
|
StrategicTickPlan {
|
|
member_activities: vec![StrategicMemberActivity {
|
|
action_digest: digest.clone(),
|
|
member_id: "mira".into(),
|
|
source_gestalt_id: "refugees-east".into(),
|
|
activity: StrategicActivityKind::Communicate,
|
|
target_subject_ids: vec!["player".into()],
|
|
location_ids: vec!["camp".into()],
|
|
public_channels: vec![],
|
|
}],
|
|
activity_outcomes: vec![StrategicActivityOutcome {
|
|
schema: "ghostlight.strategic_activity_outcome.v1".into(),
|
|
action_digest: digest,
|
|
source_subject_id: "member:mira".into(),
|
|
band: StrategicOutcomeBand::Success,
|
|
summary: "Mira keeps the promise alive despite the distance.".into(),
|
|
supporting_state_references: vec!["member:mira".into()],
|
|
effect: StrategicOutcomeEffect::MemberRelationship {
|
|
member_id: "mira".into(),
|
|
other_subject_id: "player".into(),
|
|
description: "intends to find and repay the rescuer after settling".into(),
|
|
},
|
|
}],
|
|
..Default::default()
|
|
},
|
|
)
|
|
.unwrap();
|
|
|
|
assert_eq!(value.actors["player"], player_before);
|
|
assert_eq!(
|
|
value.gestalt_members["mira"].relationships["player"],
|
|
"intends to find and repay the rescuer after settling"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn local_investigation_needs_a_location_but_not_an_invented_actor() {
|
|
let mut value = hierarchical_refugee_campaign();
|
|
let before = value.clone();
|
|
let events = apply_strategic_tick_plan(
|
|
&mut value,
|
|
resolve_test_activities(StrategicTickPlan {
|
|
gestalt_activities: vec![StrategicGestaltActivity {
|
|
action_digest: test_action_digest("local refugee investigation"),
|
|
gestalt_id: "refugees-east".into(),
|
|
activity: StrategicActivityKind::Investigate,
|
|
target_subject_ids: vec![],
|
|
location_ids: vec!["camp".into()],
|
|
public_channels: vec![],
|
|
}],
|
|
..Default::default()
|
|
}),
|
|
)
|
|
.unwrap();
|
|
assert_only_strategic_obligations_advanced(&before, &value);
|
|
assert_eq!(
|
|
events[0].summary,
|
|
"Eastern transit refugees begins a local investigation."
|
|
);
|
|
assert!(events[0].actor_ids.is_empty());
|
|
assert!(events[0].institution_ids.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn local_communication_records_the_source_without_inventing_a_listener() {
|
|
let mut value = hierarchical_refugee_campaign();
|
|
let before = value.clone();
|
|
let events = apply_strategic_tick_plan(
|
|
&mut value,
|
|
resolve_test_activities(StrategicTickPlan {
|
|
gestalt_activities: vec![StrategicGestaltActivity {
|
|
action_digest: test_action_digest("local refugee communication"),
|
|
gestalt_id: "refugees-east".into(),
|
|
activity: StrategicActivityKind::Communicate,
|
|
target_subject_ids: vec![],
|
|
location_ids: vec!["camp".into()],
|
|
public_channels: vec![],
|
|
}],
|
|
..Default::default()
|
|
}),
|
|
)
|
|
.unwrap();
|
|
assert_only_strategic_obligations_advanced(&before, &value);
|
|
assert_eq!(
|
|
events[0].summary,
|
|
"Eastern transit refugees attempts a local communication."
|
|
);
|
|
assert!(events[0].actor_ids.is_empty());
|
|
assert!(events[0].institution_ids.is_empty());
|
|
assert_eq!(events[0].gestalt_ids, vec!["refugees-east"]);
|
|
}
|
|
|
|
#[test]
|
|
fn local_obstruction_records_the_source_without_inventing_a_target() {
|
|
let mut value = hierarchical_refugee_campaign();
|
|
let before = value.clone();
|
|
let events = apply_strategic_tick_plan(
|
|
&mut value,
|
|
resolve_test_activities(StrategicTickPlan {
|
|
gestalt_activities: vec![StrategicGestaltActivity {
|
|
action_digest: test_action_digest("local infrastructure obstruction"),
|
|
gestalt_id: "refugees-east".into(),
|
|
activity: StrategicActivityKind::Obstruct,
|
|
target_subject_ids: vec![],
|
|
location_ids: vec!["camp".into()],
|
|
public_channels: vec![],
|
|
}],
|
|
..Default::default()
|
|
}),
|
|
)
|
|
.unwrap();
|
|
assert_only_strategic_obligations_advanced(&before, &value);
|
|
assert_eq!(
|
|
events[0].summary,
|
|
"Eastern transit refugees attempts local interference."
|
|
);
|
|
assert!(events[0].actor_ids.is_empty());
|
|
assert!(events[0].institution_ids.is_empty());
|
|
assert_eq!(events[0].gestalt_ids, vec!["refugees-east"]);
|
|
}
|
|
|
|
#[test]
|
|
fn dormant_member_can_speak_locally_without_inventing_a_listener() {
|
|
let mut value = hierarchical_refugee_campaign();
|
|
let before = value.clone();
|
|
let events = apply_strategic_tick_plan(
|
|
&mut value,
|
|
resolve_test_activities(StrategicTickPlan {
|
|
member_activities: vec![StrategicMemberActivity {
|
|
action_digest: test_action_digest("mira local communication"),
|
|
member_id: "mira".into(),
|
|
source_gestalt_id: "refugees-east".into(),
|
|
activity: StrategicActivityKind::Communicate,
|
|
target_subject_ids: vec![],
|
|
location_ids: vec!["camp".into()],
|
|
public_channels: vec![],
|
|
}],
|
|
..Default::default()
|
|
}),
|
|
)
|
|
.unwrap();
|
|
assert_only_strategic_obligations_advanced(&before, &value);
|
|
assert_eq!(
|
|
events[0].summary,
|
|
"Mira Venn attempts a local communication."
|
|
);
|
|
assert_eq!(events[0].actor_ids, vec!["member:mira"]);
|
|
assert!(events[0].institution_ids.is_empty());
|
|
assert_eq!(events[0].gestalt_ids, vec!["refugees-east"]);
|
|
}
|
|
|
|
#[test]
|
|
fn colocated_gestalt_can_address_a_dormant_member_without_absorbing_their_agency() {
|
|
let mut value = hierarchical_refugee_campaign();
|
|
value
|
|
.gestalt_members
|
|
.get_mut("mira")
|
|
.unwrap()
|
|
.last_location_id = Some("docks".into());
|
|
value.gestalt_members.get_mut("mira").unwrap().gestalt_id = "dock-neighbors".into();
|
|
let before = value.clone();
|
|
let events = apply_strategic_tick_plan(
|
|
&mut value,
|
|
resolve_test_activities(StrategicTickPlan {
|
|
gestalt_activities: vec![StrategicGestaltActivity {
|
|
action_digest: test_action_digest("neighbors address mira"),
|
|
gestalt_id: "dock-neighbors".into(),
|
|
activity: StrategicActivityKind::Communicate,
|
|
target_subject_ids: vec!["member:mira".into()],
|
|
location_ids: vec!["docks".into()],
|
|
public_channels: vec![],
|
|
}],
|
|
..Default::default()
|
|
}),
|
|
)
|
|
.unwrap();
|
|
assert_only_strategic_obligations_advanced(&before, &value);
|
|
assert_eq!(events.len(), 1);
|
|
assert_eq!(
|
|
events[0].summary,
|
|
"South dock neighbors sends a communication to Mira Venn."
|
|
);
|
|
assert_eq!(events[0].actor_ids, vec!["member:mira"]);
|
|
assert_eq!(events[0].gestalt_ids, vec!["dock-neighbors"]);
|
|
}
|
|
|
|
#[test]
|
|
fn gestalt_cannot_address_a_dormant_member_at_another_location() {
|
|
let mut value = hierarchical_refugee_campaign();
|
|
let before = value.clone();
|
|
let error = apply_strategic_tick_plan(
|
|
&mut value,
|
|
resolve_test_activities(StrategicTickPlan {
|
|
gestalt_activities: vec![StrategicGestaltActivity {
|
|
action_digest: test_action_digest("remote address mira"),
|
|
gestalt_id: "dock-neighbors".into(),
|
|
activity: StrategicActivityKind::Communicate,
|
|
target_subject_ids: vec!["member:mira".into()],
|
|
location_ids: vec!["docks".into()],
|
|
public_channels: vec![],
|
|
}],
|
|
..Default::default()
|
|
}),
|
|
)
|
|
.unwrap_err();
|
|
assert!(error.to_string().contains("exact graph or location scope"));
|
|
assert_eq!(value, before);
|
|
}
|
|
|
|
#[test]
|
|
fn gestalt_activity_rejects_a_nonadjacent_target_without_mutation() {
|
|
let mut value = hierarchical_refugee_campaign();
|
|
value.gestalts.insert(
|
|
"distant-crowd".into(),
|
|
GestaltPersonaState {
|
|
schema: "ghostlight.gestalt_persona_state.v1".into(),
|
|
id: "distant-crowd".into(),
|
|
name: "Distant crowd".into(),
|
|
version: 0,
|
|
home_location_id: "docks".into(),
|
|
shared_capabilities: BTreeSet::new(),
|
|
shared_knowledge: BTreeSet::new(),
|
|
resources: BTreeSet::new(),
|
|
goals: vec![],
|
|
pressures: vec![],
|
|
},
|
|
);
|
|
crate::resolution::ensure_agency_profiles(&mut value);
|
|
let before = value.clone();
|
|
let error = apply_strategic_tick_plan(
|
|
&mut value,
|
|
resolve_test_activities(StrategicTickPlan {
|
|
gestalt_activities: vec![StrategicGestaltActivity {
|
|
action_digest: test_action_digest("nonadjacent communication"),
|
|
gestalt_id: "refugees-east".into(),
|
|
activity: StrategicActivityKind::Communicate,
|
|
target_subject_ids: vec!["distant-crowd".into()],
|
|
location_ids: vec!["camp".into()],
|
|
public_channels: vec![],
|
|
}],
|
|
..Default::default()
|
|
}),
|
|
)
|
|
.unwrap_err();
|
|
assert!(error.to_string().contains("exact graph or location scope"));
|
|
assert_eq!(value, before);
|
|
}
|
|
|
|
#[test]
|
|
fn dormant_member_activity_preserves_identity_and_population_state() {
|
|
let mut value = hierarchical_refugee_campaign();
|
|
let before = value.clone();
|
|
let events = apply_strategic_tick_plan(
|
|
&mut value,
|
|
resolve_test_activities(StrategicTickPlan {
|
|
member_activities: vec![StrategicMemberActivity {
|
|
action_digest: test_action_digest("mira addresses refugees"),
|
|
member_id: "mira".into(),
|
|
source_gestalt_id: "refugees-east".into(),
|
|
activity: StrategicActivityKind::Communicate,
|
|
target_subject_ids: vec!["refugees-east".into()],
|
|
location_ids: vec!["camp".into()],
|
|
public_channels: vec![],
|
|
}],
|
|
..Default::default()
|
|
}),
|
|
)
|
|
.unwrap();
|
|
assert_only_strategic_obligations_advanced(&before, &value);
|
|
assert_eq!(events.len(), 1);
|
|
assert_eq!(events[0].kind, "gestalt_member_activity");
|
|
assert_eq!(
|
|
events[0].summary,
|
|
"Mira Venn sends a communication to Eastern transit refugees."
|
|
);
|
|
assert_eq!(events[0].actor_ids, vec!["member:mira"]);
|
|
assert_eq!(events[0].gestalt_ids, vec!["refugees-east"]);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn stale_command_cannot_mutate_campaign() {
|
|
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![],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
kernel
|
|
.command(WorldCommand::Wait {
|
|
expected_revision: 0,
|
|
minutes: 30,
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let stale = kernel
|
|
.command(WorldCommand::Wait {
|
|
expected_revision: 0,
|
|
minutes: 30,
|
|
})
|
|
.await;
|
|
assert!(matches!(stale, Err(KernelError::Stale { actual: 1, .. })));
|
|
let (_, stored): (_, Campaign) = store
|
|
.load("campaign.v1", &seed.id.to_string())
|
|
.unwrap()
|
|
.unwrap();
|
|
assert_eq!(stored.revision, 1);
|
|
assert_eq!(stored.world_time, seed.world_time + Duration::minutes(30));
|
|
assert_eq!(
|
|
store.keys("mutation_authority_envelope.v1").unwrap().len(),
|
|
1
|
|
);
|
|
assert_eq!(store.keys("world_mutation_batch.v1").unwrap().len(), 1);
|
|
assert_eq!(store.keys("world_mutation_receipt.v1").unwrap().len(), 1);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn invalid_wait_and_oversized_speech_cannot_mutate_campaign() {
|
|
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![],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let baseline = store
|
|
.load::<Campaign>("campaign.v1", &seed.id.to_string())
|
|
.unwrap()
|
|
.unwrap()
|
|
.1;
|
|
|
|
assert!(
|
|
kernel
|
|
.command(WorldCommand::Wait {
|
|
expected_revision: 0,
|
|
minutes: 1_441,
|
|
})
|
|
.await
|
|
.is_err()
|
|
);
|
|
assert!(
|
|
kernel
|
|
.command(WorldCommand::Speak {
|
|
expected_revision: 0,
|
|
actor_id: "player".into(),
|
|
text: "x".repeat(4_001),
|
|
intended_effect: None,
|
|
persona_response_actor_ids: BTreeSet::new(),
|
|
})
|
|
.await
|
|
.is_err()
|
|
);
|
|
let stored = store
|
|
.load::<Campaign>("campaign.v1", &seed.id.to_string())
|
|
.unwrap()
|
|
.unwrap()
|
|
.1;
|
|
assert_eq!(stored, baseline);
|
|
assert!(store.keys("world_commit_receipt.v1").unwrap().is_empty());
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn speech_can_bind_a_nearby_folded_person_then_materialize_that_exact_member() {
|
|
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(
|
|
"refugees".into(),
|
|
GestaltPersonaState {
|
|
schema: "ghostlight.gestalt_persona_state.v1".into(),
|
|
id: "refugees".into(),
|
|
name: "Refugees".into(),
|
|
version: 4,
|
|
home_location_id: "room".into(),
|
|
shared_capabilities: BTreeSet::new(),
|
|
shared_knowledge: BTreeSet::new(),
|
|
resources: BTreeSet::new(),
|
|
goals: vec![],
|
|
pressures: vec![],
|
|
},
|
|
);
|
|
seed.gestalt_members.insert(
|
|
"water-cart-taren".into(),
|
|
GestaltMemberDelta {
|
|
schema: "ghostlight.gestalt_member_delta.v1".into(),
|
|
id: "water-cart-taren".into(),
|
|
gestalt_id: "refugees".into(),
|
|
version: 7,
|
|
name: "Taren".into(),
|
|
capability_additions: BTreeSet::new(),
|
|
capability_removals: BTreeSet::new(),
|
|
knowledge_additions: BTreeSet::new(),
|
|
knowledge_removals: BTreeSet::new(),
|
|
equipment: BTreeSet::from(["water handcart".into()]),
|
|
conditions: BTreeSet::new(),
|
|
obligations: BTreeSet::new(),
|
|
relationships: BTreeMap::new(),
|
|
goals: vec![],
|
|
memories: vec!["Ash repaired the coupling".into()],
|
|
last_location_id: Some("room".into()),
|
|
materialized_actor_id: None,
|
|
last_relevant_revision: 0,
|
|
relevance_lease_until_revision: 0,
|
|
},
|
|
);
|
|
crate::resolution::ensure_agency_profiles(&mut seed);
|
|
kernel
|
|
.command(WorldCommand::CreateCampaign {
|
|
campaign: seed,
|
|
evidence_receipts: vec![],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
|
|
let spoken = kernel
|
|
.command(WorldCommand::Speak {
|
|
expected_revision: 0,
|
|
actor_id: "player".into(),
|
|
text: "Taren with the water handcart, is the coupling holding?".into(),
|
|
intended_effect: None,
|
|
persona_response_actor_ids: BTreeSet::from(["member:water-cart-taren".into()]),
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let CommandResult::Committed { campaign, .. } = spoken else {
|
|
panic!("speech did not commit")
|
|
};
|
|
assert!(!campaign.actors.contains_key("member:water-cart-taren"));
|
|
let plan = crate::gestalt::required_addressed_promotions(&campaign).unwrap();
|
|
assert_eq!(plan.promotions.len(), 1);
|
|
assert_eq!(plan.promotions[0].expected_gestalt_version, 4);
|
|
assert_eq!(plan.promotions[0].expected_member_version, 7);
|
|
|
|
let reconciled = kernel
|
|
.command(WorldCommand::ReconcileGestaltPresence {
|
|
expected_revision: 1,
|
|
reason: "player says: Taren with the water handcart, is the coupling holding?"
|
|
.into(),
|
|
plan,
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let CommandResult::Committed { campaign, .. } = reconciled else {
|
|
panic!("addressed member was not materialized")
|
|
};
|
|
assert!(campaign.actors.contains_key("member:water-cart-taren"));
|
|
assert_eq!(
|
|
campaign.gestalt_members["water-cart-taren"]
|
|
.materialized_actor_id
|
|
.as_deref(),
|
|
Some("member:water-cart-taren")
|
|
);
|
|
let arrival = campaign.transcript.last().unwrap();
|
|
assert_eq!(arrival.speaker, "world");
|
|
assert!(arrival.text.contains("Taren"));
|
|
assert!(arrival.text.contains("Refugees"));
|
|
assert!(arrival.text.contains("Room"));
|
|
assert!(
|
|
campaign
|
|
.transcript
|
|
.iter()
|
|
.rev()
|
|
.find(|turn| turn.speaker == campaign.player_actor_id)
|
|
.unwrap()
|
|
.persona_response_actor_ids
|
|
== BTreeSet::from(["member:water-cart-taren".into()])
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn npc_speech_does_not_impersonate_player_activity() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let store = CampaignStore::open(dir.path().join("campaign.cc")).unwrap();
|
|
let kernel = WorldKernel::start(store);
|
|
let mut seed = campaign();
|
|
let inactive_since = Utc::now() - Duration::hours(2);
|
|
seed.last_player_activity = inactive_since;
|
|
let mut npc = seed.actors["player"].clone();
|
|
npc.id = "npc".into();
|
|
npc.name = "NPC".into();
|
|
seed.actors.insert("npc".into(), npc);
|
|
kernel
|
|
.command(WorldCommand::CreateCampaign {
|
|
campaign: seed,
|
|
evidence_receipts: vec![],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let result = kernel
|
|
.command(WorldCommand::Speak {
|
|
expected_revision: 0,
|
|
actor_id: "npc".into(),
|
|
text: "The world does not wait.".into(),
|
|
intended_effect: None,
|
|
persona_response_actor_ids: BTreeSet::new(),
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let CommandResult::Committed { campaign, .. } = result else {
|
|
panic!()
|
|
};
|
|
assert_eq!(campaign.last_player_activity, inactive_since);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn assessment_is_private_and_attempt_commits_roll_atomically() {
|
|
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![],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let result = kernel
|
|
.command(WorldCommand::Assess {
|
|
expected_revision: 0,
|
|
intent: ActionIntent {
|
|
actor_id: "player".into(),
|
|
description: "Open the ordinary door".into(),
|
|
intended_effect: "Pass through".into(),
|
|
},
|
|
proposal: None,
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let CommandResult::Assessed { assessment } = result else {
|
|
panic!("expected assessment")
|
|
};
|
|
let (_, before): (_, Campaign) = store
|
|
.load("campaign.v1", &seed.id.to_string())
|
|
.unwrap()
|
|
.unwrap();
|
|
assert_eq!(before.revision, 0);
|
|
let result = kernel
|
|
.command(WorldCommand::Attempt {
|
|
actor_id: "player".into(),
|
|
assessment_digest: assessment.digest,
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let CommandResult::Committed { campaign, receipt } = result else {
|
|
panic!("expected commit")
|
|
};
|
|
assert_eq!(campaign.revision, 1);
|
|
assert!(receipt.roll.is_some());
|
|
assert_eq!(store.keys("world_commit_receipt.v1").unwrap().len(), 1);
|
|
assert_eq!(store.keys("roll_receipt.v1").unwrap().len(), 1);
|
|
assert_eq!(
|
|
store.keys("mutation_authority_envelope.v1").unwrap().len(),
|
|
1
|
|
);
|
|
assert_eq!(store.keys("world_mutation_batch.v1").unwrap().len(), 1);
|
|
assert_eq!(store.keys("world_mutation_receipt.v1").unwrap().len(), 1);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn repair_assessment_persists_reduced_world_pressure() {
|
|
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.clocks.insert(
|
|
"clinic-failure".into(),
|
|
WorldClock {
|
|
id: "clinic-failure".into(),
|
|
label: "Clinic failure".into(),
|
|
progress: 3,
|
|
threshold: 4,
|
|
consequence: "The regulator fails.".into(),
|
|
},
|
|
);
|
|
kernel
|
|
.command(WorldCommand::CreateCampaign {
|
|
campaign: seed.clone(),
|
|
evidence_receipts: vec![],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let intent = ActionIntent {
|
|
actor_id: "player".into(),
|
|
description: "Patch the failing regulator seal".into(),
|
|
intended_effect: "Relieve immediate clinic failure pressure".into(),
|
|
};
|
|
let reduction = WorldEffectDelta {
|
|
clock_reductions: BTreeMap::from([("clinic-failure".into(), 2)]),
|
|
..Default::default()
|
|
};
|
|
let mut assessment = assess(&seed, intent.clone());
|
|
assessment.strong_effect = reduction.clone();
|
|
assessment.success_effect = reduction.clone();
|
|
assessment.mixed_effect = reduction.clone();
|
|
// Keep the effect identical across bands so this test exercises the
|
|
// atomic reduction primitive independently of the OS-random roll.
|
|
assessment.failure_effect = reduction;
|
|
assessment.digest = crate::assessor::assessment_digest(&assessment).unwrap();
|
|
kernel
|
|
.command(WorldCommand::Assess {
|
|
expected_revision: 0,
|
|
intent,
|
|
proposal: Some(assessment.clone()),
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let result = kernel
|
|
.command(WorldCommand::Attempt {
|
|
actor_id: "player".into(),
|
|
assessment_digest: assessment.digest,
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let CommandResult::Committed { campaign, .. } = result else {
|
|
panic!("expected repair commit")
|
|
};
|
|
|
|
assert_eq!(campaign.clocks["clinic-failure"].progress, 1);
|
|
assert_eq!(campaign.revision, 1);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn stale_assessment_returns_original_intent_for_fresh_compilation() {
|
|
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![],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let intent = ActionIntent {
|
|
actor_id: "player".into(),
|
|
description: "Open the ordinary door".into(),
|
|
intended_effect: "Pass through".into(),
|
|
};
|
|
let CommandResult::Assessed { assessment } = kernel
|
|
.command(WorldCommand::Assess {
|
|
expected_revision: 0,
|
|
intent: intent.clone(),
|
|
proposal: None,
|
|
})
|
|
.await
|
|
.unwrap()
|
|
else {
|
|
panic!()
|
|
};
|
|
kernel
|
|
.command(WorldCommand::Speak {
|
|
expected_revision: 0,
|
|
actor_id: "player".into(),
|
|
text: "Wait.".into(),
|
|
intended_effect: None,
|
|
persona_response_actor_ids: BTreeSet::new(),
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let error = kernel
|
|
.command(WorldCommand::Attempt {
|
|
actor_id: "player".into(),
|
|
assessment_digest: assessment.digest,
|
|
})
|
|
.await
|
|
.unwrap_err();
|
|
match error {
|
|
KernelError::StaleAssessment {
|
|
intent: stale_intent,
|
|
actual_revision,
|
|
} => {
|
|
assert_eq!(stale_intent, intent);
|
|
assert_eq!(actual_revision, 1);
|
|
}
|
|
other => panic!("unexpected error: {other}"),
|
|
}
|
|
assert!(store.keys("roll_receipt.v1").unwrap().is_empty());
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn strategic_tick_without_an_admitted_wave_advances_only_deterministic_obligations() {
|
|
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![],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let result = kernel
|
|
.command(WorldCommand::AdvanceStrategicTick {
|
|
expected_revision: 0,
|
|
source: TickSource::Scheduler,
|
|
plan: None,
|
|
model_receipt_hash: None,
|
|
resolution_wave: None,
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let CommandResult::Committed { campaign, .. } = result else {
|
|
panic!("expected commit")
|
|
};
|
|
assert!(campaign.events.is_empty());
|
|
assert!(campaign.news.is_empty());
|
|
assert_eq!(campaign.away_ticks_processed, 1);
|
|
assert_eq!(campaign.institutions["board"].posture, "watching");
|
|
assert_eq!(campaign.world_time, seed.world_time + Duration::hours(6));
|
|
let ticks = store
|
|
.load_all::<crate::domain::StrategicTickReceipt>("strategic_tick.v1")
|
|
.unwrap();
|
|
assert_eq!(ticks.len(), 1);
|
|
assert_eq!(ticks[0].source, TickSource::Scheduler);
|
|
assert!(ticks[0].event_ids.is_empty());
|
|
assert!(ticks[0].model_receipt_hash.is_none());
|
|
assert_eq!(store.keys("world_mutation_receipt.v1").unwrap().len(), 1);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn strategic_plan_moves_remote_actors_but_cannot_puppet_the_player() {
|
|
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.locations.get_mut("room").unwrap().routes.insert(
|
|
"road".into(),
|
|
Route {
|
|
destination_id: "yard".into(),
|
|
distance: "near".into(),
|
|
travel_minutes: 20,
|
|
},
|
|
);
|
|
seed.locations.insert(
|
|
"yard".into(),
|
|
Location {
|
|
id: "yard".into(),
|
|
name: "Yard".into(),
|
|
container_id: None,
|
|
routes: BTreeMap::from([(
|
|
"back".into(),
|
|
Route {
|
|
destination_id: "room".into(),
|
|
distance: "near".into(),
|
|
travel_minutes: 20,
|
|
},
|
|
)]),
|
|
persistent_features: vec![],
|
|
},
|
|
);
|
|
let mut npc = seed.actors["player"].clone();
|
|
npc.id = "runner".into();
|
|
npc.name = "Runner".into();
|
|
seed.actors.insert(npc.id.clone(), npc);
|
|
kernel
|
|
.command(WorldCommand::CreateCampaign {
|
|
campaign: seed.clone(),
|
|
evidence_receipts: vec![],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
|
|
let puppet = crate::domain::StrategicTickPlan {
|
|
actor_moves: vec![crate::domain::StrategicActorMove {
|
|
actor_id: "player".into(),
|
|
destination_id: "yard".into(),
|
|
public_channels: vec![],
|
|
}],
|
|
..Default::default()
|
|
};
|
|
assert!(matches!(
|
|
kernel
|
|
.command(WorldCommand::AdvanceStrategicTick {
|
|
expected_revision: 0,
|
|
source: TickSource::Scheduler,
|
|
plan: Some(puppet),
|
|
model_receipt_hash: Some(format!("sha256:{}", "a".repeat(64))),
|
|
resolution_wave: None,
|
|
})
|
|
.await,
|
|
Err(KernelError::Invalid(_))
|
|
));
|
|
let (_, unchanged): (_, Campaign) = store
|
|
.load("campaign.v1", &seed.id.to_string())
|
|
.unwrap()
|
|
.unwrap();
|
|
assert_eq!(unchanged.revision, 0);
|
|
assert_eq!(unchanged.actors["player"].location_id, "room");
|
|
|
|
let valid = crate::domain::StrategicTickPlan {
|
|
actor_moves: vec![crate::domain::StrategicActorMove {
|
|
actor_id: "runner".into(),
|
|
destination_id: "yard".into(),
|
|
public_channels: vec!["courier-network".into()],
|
|
}],
|
|
..Default::default()
|
|
};
|
|
let result = kernel
|
|
.command(WorldCommand::AdvanceStrategicTick {
|
|
expected_revision: 0,
|
|
source: TickSource::Scheduler,
|
|
plan: Some(valid),
|
|
model_receipt_hash: Some(format!("sha256:{}", "b".repeat(64))),
|
|
resolution_wave: None,
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let CommandResult::Committed { campaign, .. } = result else {
|
|
panic!("expected commit")
|
|
};
|
|
assert_eq!(campaign.actors["runner"].location_id, "yard");
|
|
assert_eq!(campaign.actors["player"].location_id, "room");
|
|
assert_eq!(campaign.events[0].kind, "actor_movement");
|
|
assert_eq!(
|
|
campaign.events[0].summary,
|
|
"Runner moves from Room to Yard."
|
|
);
|
|
assert!(!campaign.events[0].summary.contains("room"));
|
|
assert!(!campaign.events[0].summary.contains("yard"));
|
|
let ticks = store
|
|
.load_all::<crate::domain::StrategicTickReceipt>("strategic_tick.v1")
|
|
.unwrap();
|
|
assert_eq!(
|
|
ticks[0].model_receipt_hash,
|
|
Some(format!("sha256:{}", "b".repeat(64)))
|
|
);
|
|
|
|
let actor_activity = resolve_test_activities(crate::domain::StrategicTickPlan {
|
|
actor_activities: vec![crate::domain::StrategicActorActivity {
|
|
action_digest: test_action_digest("runner-investigates-yard"),
|
|
actor_id: "runner".into(),
|
|
activity: StrategicActivityKind::Investigate,
|
|
target_subject_ids: vec![],
|
|
location_ids: vec!["yard".into()],
|
|
public_channels: vec![],
|
|
}],
|
|
..Default::default()
|
|
});
|
|
let result = kernel
|
|
.command(WorldCommand::AdvanceStrategicTick {
|
|
expected_revision: 1,
|
|
source: TickSource::Scheduler,
|
|
plan: Some(actor_activity),
|
|
model_receipt_hash: Some(format!("sha256:{}", "c".repeat(64))),
|
|
resolution_wave: None,
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let CommandResult::Committed { campaign, .. } = result else {
|
|
panic!("expected commit")
|
|
};
|
|
assert_eq!(campaign.actors["runner"].location_id, "yard");
|
|
assert_eq!(campaign.actors["player"].location_id, "room");
|
|
assert!(
|
|
campaign
|
|
.events
|
|
.iter()
|
|
.any(|event| event.kind == "actor_activity"
|
|
&& event.actor_ids.contains(&"runner".to_owned()))
|
|
);
|
|
assert!(
|
|
campaign
|
|
.events
|
|
.iter()
|
|
.all(|event| event.kind != "strategic_activity_outcome")
|
|
);
|
|
|
|
let origin_activity = crate::domain::CellActionProposal {
|
|
subject_id: "runner".into(),
|
|
intent: "Repair the yard marker, then return to the room.".into(),
|
|
intended_effect: "Attempt the repair before leaving the yard.".into(),
|
|
priority: 50,
|
|
state_references: vec![],
|
|
public_channels: vec![],
|
|
effects: vec![
|
|
crate::domain::StrategicCellEffect::ActorMove {
|
|
actor_id: "runner".into(),
|
|
destination_id: "room".into(),
|
|
},
|
|
crate::domain::StrategicCellEffect::ActorActivity {
|
|
actor_id: "runner".into(),
|
|
activity: StrategicActivityKind::Prepare,
|
|
target_subject_ids: vec![],
|
|
location_ids: vec!["yard".into()],
|
|
},
|
|
],
|
|
};
|
|
let action_digest = crate::resolution::cell_action_digest(&origin_activity).unwrap();
|
|
let result = kernel
|
|
.command(WorldCommand::AdvanceStrategicTick {
|
|
expected_revision: 2,
|
|
source: TickSource::Scheduler,
|
|
plan: Some(StrategicTickPlan {
|
|
selected_actions: vec![origin_activity],
|
|
activity_outcomes: vec![StrategicActivityOutcome {
|
|
schema: "ghostlight.strategic_activity_outcome.v1".into(),
|
|
action_digest: action_digest.clone(),
|
|
source_subject_id: "runner".into(),
|
|
band: StrategicOutcomeBand::Mixed,
|
|
summary: "The yard repair remains provisional.".into(),
|
|
supporting_state_references: vec![],
|
|
effect: StrategicOutcomeEffect::NoMaterialChange {
|
|
reason: "The repair did not establish a durable state change.".into(),
|
|
},
|
|
}],
|
|
..StrategicTickPlan::default()
|
|
}),
|
|
model_receipt_hash: Some(format!("sha256:{}", "d".repeat(64))),
|
|
resolution_wave: None,
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let CommandResult::Committed { campaign, .. } = result else {
|
|
panic!("expected commit")
|
|
};
|
|
assert_eq!(campaign.actors["runner"].location_id, "room");
|
|
let activity_index = campaign
|
|
.events
|
|
.iter()
|
|
.position(|event| {
|
|
event
|
|
.id
|
|
.starts_with("strategic:3:actor-activity:runner:prepare:")
|
|
})
|
|
.unwrap();
|
|
let movement_index = campaign
|
|
.events
|
|
.iter()
|
|
.position(|event| event.id == "strategic:3:actor:runner")
|
|
.unwrap();
|
|
assert_eq!(
|
|
campaign.events[activity_index].summary,
|
|
"Runner attempts the repair before leaving the yard."
|
|
);
|
|
assert!(
|
|
campaign
|
|
.events
|
|
.iter()
|
|
.all(|event| !event.id.starts_with("strategic:3:activity-outcome:"))
|
|
);
|
|
assert!(activity_index < movement_index);
|
|
}
|
|
|
|
#[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![],
|
|
model_stage_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![SourceWitness {
|
|
source_id: "lore/roads.md".into(),
|
|
exact_locator: "line:10".into(),
|
|
content_hash: "sha256:witness".into(),
|
|
excerpt: "The annex road remains open.".into(),
|
|
authority_lane: "canon".into(),
|
|
temporal_scope: "fixture-era".into(),
|
|
}],
|
|
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(),
|
|
origin_routes: BTreeMap::from([(
|
|
"to-annex".into(),
|
|
Route {
|
|
destination_id: "annex".into(),
|
|
distance: "near".into(),
|
|
travel_minutes: 10,
|
|
},
|
|
)]),
|
|
locations: vec![location],
|
|
facts: vec![WorldFact {
|
|
id: "annex-gate".into(),
|
|
statement: "The annex gate is maintained from the inner booth.".into(),
|
|
scope: FactScope::BranchLocal,
|
|
evidence_receipt_ids: vec![evidence.id.clone()],
|
|
discoverable_at_location_ids: BTreeSet::from(["annex".into()]),
|
|
}],
|
|
populations: vec![],
|
|
population_profiles: vec![],
|
|
migration_relations: vec![],
|
|
institutions: vec![],
|
|
institution_profiles: vec![],
|
|
local_relations: vec![],
|
|
civic_system: None,
|
|
},
|
|
evidence_receipts: vec![evidence],
|
|
canon_candidates: vec![candidate],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let CommandResult::Committed { campaign, .. } = result else {
|
|
panic!("expected commit")
|
|
};
|
|
assert!(campaign.locations.contains_key("annex"));
|
|
assert_eq!(
|
|
campaign.locations["room"].routes["to-annex"].destination_id,
|
|
"annex"
|
|
);
|
|
assert_eq!(campaign.revision, 1);
|
|
assert_eq!(
|
|
campaign.facts["annex-gate"].discoverable_at_location_ids,
|
|
BTreeSet::from(["annex".into()])
|
|
);
|
|
assert_eq!(store.keys("vault_evidence_receipt.v1").unwrap().len(), 1);
|
|
assert_eq!(store.keys("canon_candidate.v1").unwrap().len(), 1);
|
|
assert_eq!(store.keys("world_mutation_batch.v1").unwrap().len(), 1);
|
|
assert_eq!(store.keys("world_mutation_receipt.v1").unwrap().len(), 1);
|
|
let batches = store
|
|
.load_all::<crate::transition::WorldMutationBatch>("world_mutation_batch.v1")
|
|
.unwrap();
|
|
assert_eq!(batches[0].mutations.len(), 4);
|
|
assert_eq!(
|
|
batches[0]
|
|
.mutations
|
|
.iter()
|
|
.filter(|mutation| matches!(
|
|
&mutation.mutation,
|
|
crate::transition::WorldMutation::AdmitEntity { .. }
|
|
))
|
|
.count(),
|
|
2
|
|
);
|
|
let (_, manifest): (_, VaultManifest) = store
|
|
.load("vault_manifest.v1", &seed.id.to_string())
|
|
.unwrap()
|
|
.unwrap();
|
|
assert!(manifest.source_ids.contains("lore/roads.md"));
|
|
assert!(manifest.authority_lanes.contains("canon"));
|
|
assert!(manifest.temporal_scopes.contains("fixture-era"));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn inhabited_region_admission_preserves_people_and_invalidates_only_derived_cover() {
|
|
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.gestalts.insert(
|
|
"refugees".into(),
|
|
GestaltPersonaState {
|
|
schema: "ghostlight.gestalt_persona_state.v1".into(),
|
|
id: "refugees".into(),
|
|
name: "Refugees".into(),
|
|
version: 0,
|
|
home_location_id: "room".into(),
|
|
shared_capabilities: BTreeSet::new(),
|
|
shared_knowledge: BTreeSet::new(),
|
|
resources: BTreeSet::new(),
|
|
goals: vec!["seek voluntary settlement".into()],
|
|
pressures: vec![],
|
|
},
|
|
);
|
|
seed.gestalt_members.insert(
|
|
"taren".into(),
|
|
GestaltMemberDelta {
|
|
schema: "ghostlight.gestalt_member_delta.v1".into(),
|
|
id: "taren".into(),
|
|
gestalt_id: "refugees".into(),
|
|
version: 3,
|
|
name: "Taren".into(),
|
|
capability_additions: BTreeSet::new(),
|
|
capability_removals: BTreeSet::new(),
|
|
knowledge_additions: BTreeSet::new(),
|
|
knowledge_removals: BTreeSet::new(),
|
|
equipment: BTreeSet::new(),
|
|
conditions: BTreeSet::new(),
|
|
obligations: BTreeSet::new(),
|
|
relationships: BTreeMap::new(),
|
|
goals: vec!["reach the ridge villages".into()],
|
|
memories: vec!["Ash repaired my regulator".into()],
|
|
last_location_id: Some("room".into()),
|
|
materialized_actor_id: None,
|
|
last_relevant_revision: 0,
|
|
relevance_lease_until_revision: 0,
|
|
},
|
|
);
|
|
crate::resolution::ensure_agency_profiles(&mut seed);
|
|
let original_member = seed.gestalt_members["taren"].clone();
|
|
let original_epoch = seed.resolution_policy.resolution_epoch;
|
|
kernel
|
|
.command(WorldCommand::CreateCampaign {
|
|
campaign: seed,
|
|
evidence_receipts: vec![],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let evidence = VaultEvidenceReceipt {
|
|
schema: "ghostlight.vault_evidence_receipt.v1".into(),
|
|
id: "vault:ridge".into(),
|
|
provider: "fixture".into(),
|
|
query_hash: "sha256:q".into(),
|
|
witnesses: vec![],
|
|
retrieved_at: Utc::now(),
|
|
};
|
|
let statement = "The ridge assembly governs voluntary admission.".to_owned();
|
|
let population = GestaltPersonaState {
|
|
schema: "ghostlight.gestalt_persona_state.v1".into(),
|
|
id: "ridge-households".into(),
|
|
name: "Ridge Households".into(),
|
|
version: 0,
|
|
home_location_id: "ridge".into(),
|
|
shared_capabilities: BTreeSet::from(["communal agriculture".into()]),
|
|
shared_knowledge: BTreeSet::from([statement.clone()]),
|
|
resources: BTreeSet::from(["shared kitchen".into()]),
|
|
goals: vec!["decide admissions collectively".into()],
|
|
pressures: vec!["winter capacity is finite".into()],
|
|
};
|
|
let profile = AgencyProfile {
|
|
schema: "ghostlight.agency_profile.v1".into(),
|
|
id: "agency:ridge-households".into(),
|
|
subject_id: population.id.clone(),
|
|
subject_kind: AgencySubjectKind::Gestalt,
|
|
profile_version: 0,
|
|
collective_authority_id: Some(population.id.clone()),
|
|
parent_subject_id: None,
|
|
active_leaf: true,
|
|
simulation_eligible: true,
|
|
facets: BTreeMap::from([
|
|
(AgencyAxis::Geography, BTreeSet::from(["ridge".into()])),
|
|
(AgencyAxis::Ideology, BTreeSet::from(["consent".into()])),
|
|
(AgencyAxis::Authority, BTreeSet::from(["assembly".into()])),
|
|
(
|
|
AgencyAxis::EconomyRole,
|
|
BTreeSet::from(["agriculture".into()]),
|
|
),
|
|
(AgencyAxis::SpeciesBody, BTreeSet::from(["mixed".into()])),
|
|
(AgencyAxis::Information, BTreeSet::from(["local".into()])),
|
|
]),
|
|
location_ids: BTreeSet::from(["ridge".into()]),
|
|
information_channels: BTreeSet::from(["village assembly bulletin".into()]),
|
|
detail_debt: 0,
|
|
last_detail_tick: 0,
|
|
evidence_receipt_ids: vec![evidence.id.clone()],
|
|
};
|
|
let relation = AgencyRelation {
|
|
schema: "ghostlight.agency_relation.v1".into(),
|
|
id: "migration:refugees:ridge".into(),
|
|
from_subject_id: "refugees".into(),
|
|
to_subject_id: population.id.clone(),
|
|
kind: AgencyRelationKind::Migration,
|
|
strength: 50,
|
|
active: true,
|
|
evidence_receipt_ids: vec![evidence.id.clone()],
|
|
};
|
|
let result = kernel
|
|
.command(WorldCommand::ExpandRegion {
|
|
expected_revision: 0,
|
|
expansion: RegionExpansion {
|
|
origin_location_id: "room".into(),
|
|
origin_routes: BTreeMap::from([(
|
|
"to-ridge".into(),
|
|
Route {
|
|
destination_id: "ridge".into(),
|
|
distance: "2 km".into(),
|
|
travel_minutes: 20,
|
|
},
|
|
)]),
|
|
locations: vec![Location {
|
|
id: "ridge".into(),
|
|
name: "Ridge Village".into(),
|
|
container_id: None,
|
|
routes: BTreeMap::from([(
|
|
"to-room".into(),
|
|
Route {
|
|
destination_id: "room".into(),
|
|
distance: "2 km".into(),
|
|
travel_minutes: 20,
|
|
},
|
|
)]),
|
|
persistent_features: vec!["assembly hall".into()],
|
|
}],
|
|
facts: vec![WorldFact {
|
|
id: "ridge-admission".into(),
|
|
statement,
|
|
scope: FactScope::ProvisionalLocal,
|
|
evidence_receipt_ids: vec![evidence.id.clone()],
|
|
discoverable_at_location_ids: BTreeSet::from(["ridge".into()]),
|
|
}],
|
|
populations: vec![population],
|
|
population_profiles: vec![profile],
|
|
migration_relations: vec![relation],
|
|
institutions: vec![],
|
|
institution_profiles: vec![],
|
|
local_relations: vec![],
|
|
civic_system: None,
|
|
},
|
|
evidence_receipts: vec![evidence],
|
|
canon_candidates: vec![],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let CommandResult::Committed { campaign, .. } = result else {
|
|
panic!("expected commit")
|
|
};
|
|
assert_eq!(campaign.gestalt_members["taren"], original_member);
|
|
assert_eq!(campaign.gestalts["refugees"].home_location_id, "room");
|
|
assert_eq!(
|
|
campaign.gestalts["ridge-households"].home_location_id,
|
|
"ridge"
|
|
);
|
|
assert_eq!(
|
|
campaign.agency_relations["migration:refugees:ridge"].kind,
|
|
AgencyRelationKind::Migration
|
|
);
|
|
assert_eq!(
|
|
campaign.resolution_policy.resolution_epoch,
|
|
original_epoch + 1
|
|
);
|
|
assert!(campaign.resolution_cover.is_none());
|
|
assert_eq!(
|
|
crate::resolution::gestalt_migration_destinations(&campaign, "refugees", "room")["ridge-households"],
|
|
"ridge"
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn locality_elaboration_preserves_the_city_and_grounds_a_named_residents_vote() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let store = CampaignStore::open(dir.path().join("campaign.cc")).unwrap();
|
|
let kernel = WorldKernel::start(store);
|
|
let seed = campaign();
|
|
let original = seed.locations["room"].clone();
|
|
let mut elaboration = civic_locality_elaboration();
|
|
let verifier_receipt = civic_verifier_receipt(&seed, &mut elaboration.expansion);
|
|
kernel
|
|
.command(WorldCommand::CreateCampaign {
|
|
campaign: seed,
|
|
evidence_receipts: vec![],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
|
|
let committed = kernel
|
|
.command(WorldCommand::ElaborateLocality {
|
|
expected_revision: 0,
|
|
elaboration,
|
|
evidence_receipts: vec![],
|
|
canon_candidates: vec![],
|
|
model_stage_receipts: vec![verifier_receipt],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let CommandResult::Committed {
|
|
campaign: elaborated,
|
|
..
|
|
} = committed
|
|
else {
|
|
panic!("expected committed locality elaboration")
|
|
};
|
|
assert_eq!(elaborated.locations["room"].id, original.id);
|
|
assert_eq!(elaborated.locations["room"].name, original.name);
|
|
assert_eq!(
|
|
elaborated.locations["room"].persistent_features,
|
|
original.persistent_features
|
|
);
|
|
assert_eq!(
|
|
elaborated.locations["civic-quarter"]
|
|
.container_id
|
|
.as_deref(),
|
|
Some("room")
|
|
);
|
|
assert_eq!(elaborated.institutions.len(), 2);
|
|
assert_eq!(elaborated.civic_systems["room"].version, 0);
|
|
assert!(
|
|
!elaborated.civic_systems["room"]
|
|
.semantic_verification_receipt_id
|
|
.is_empty()
|
|
);
|
|
assert_eq!(
|
|
elaborated.agency_relations["relation:mayor-assembly"].kind,
|
|
AgencyRelationKind::Rivalry
|
|
);
|
|
let selection = elaborated.facts["fact:room-selection"].statement.clone();
|
|
assert!(
|
|
elaborated.gestalts["room-residents"]
|
|
.shared_knowledge
|
|
.contains(&selection)
|
|
);
|
|
|
|
let named = kernel
|
|
.command(WorldCommand::IndividuateGestaltMember {
|
|
expected_revision: 1,
|
|
individuation: GestaltIndividuation {
|
|
gestalt_id: "room-residents".into(),
|
|
expected_gestalt_version: 0,
|
|
member: GestaltMemberDelta {
|
|
schema: "ghostlight.gestalt_member_delta.v1".into(),
|
|
id: "iren-vale".into(),
|
|
gestalt_id: "room-residents".into(),
|
|
version: 0,
|
|
name: "Iren Vale".into(),
|
|
capability_additions: BTreeSet::new(),
|
|
capability_removals: BTreeSet::new(),
|
|
knowledge_additions: BTreeSet::new(),
|
|
knowledge_removals: BTreeSet::new(),
|
|
equipment: BTreeSet::new(),
|
|
conditions: BTreeSet::new(),
|
|
obligations: BTreeSet::new(),
|
|
relationships: BTreeMap::new(),
|
|
goals: vec!["make berth dues transparent".into()],
|
|
memories: vec![
|
|
"I voted for Oren Vale because he promised a public berth audit."
|
|
.into(),
|
|
],
|
|
last_location_id: Some("civic-quarter".into()),
|
|
materialized_actor_id: None,
|
|
last_relevant_revision: 0,
|
|
relevance_lease_until_revision: 0,
|
|
},
|
|
location_id: "civic-quarter".into(),
|
|
},
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let CommandResult::Committed {
|
|
campaign: individuated,
|
|
..
|
|
} = named
|
|
else {
|
|
panic!("expected committed resident individuation")
|
|
};
|
|
let resident = &individuated.actors["member:iren-vale"];
|
|
assert!(resident.knowledge.contains(&selection));
|
|
assert!(resident.memories[0].contains("Oren Vale"));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn invalid_civic_locality_leaves_the_coarse_city_untouched() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let store = CampaignStore::open(dir.path().join("campaign.cc")).unwrap();
|
|
let kernel = WorldKernel::start(store.clone());
|
|
let seed = campaign();
|
|
let campaign_id = seed.id;
|
|
kernel
|
|
.command(WorldCommand::CreateCampaign {
|
|
campaign: seed,
|
|
evidence_receipts: vec![],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let mut elaboration = civic_locality_elaboration();
|
|
elaboration.expansion.populations[0]
|
|
.shared_knowledge
|
|
.remove("Residents elected Selka Vey over Oren Vale at the last mayoral ballot.");
|
|
|
|
let error = kernel
|
|
.command(WorldCommand::ElaborateLocality {
|
|
expected_revision: 0,
|
|
elaboration,
|
|
evidence_receipts: vec![],
|
|
canon_candidates: vec![],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap_err();
|
|
assert!(error.to_string().contains("public civic facts"));
|
|
let stored = store
|
|
.load::<Campaign>("campaign.v1", &campaign_id.to_string())
|
|
.unwrap()
|
|
.unwrap()
|
|
.1;
|
|
assert_eq!(stored.revision, 0);
|
|
assert_eq!(stored.locations.len(), 1);
|
|
assert!(stored.institutions.is_empty());
|
|
assert!(stored.gestalts.is_empty());
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn structurally_valid_civic_locality_requires_its_bound_semantic_receipt() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let store = CampaignStore::open(dir.path().join("campaign.cc")).unwrap();
|
|
let kernel = WorldKernel::start(store.clone());
|
|
let seed = campaign();
|
|
let campaign_id = seed.id;
|
|
kernel
|
|
.command(WorldCommand::CreateCampaign {
|
|
campaign: seed,
|
|
evidence_receipts: vec![],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
|
|
let error = kernel
|
|
.command(WorldCommand::ElaborateLocality {
|
|
expected_revision: 0,
|
|
elaboration: civic_locality_elaboration(),
|
|
evidence_receipts: vec![],
|
|
canon_candidates: vec![],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap_err();
|
|
assert!(
|
|
error.to_string().contains("semantic verifier receipt"),
|
|
"{error}"
|
|
);
|
|
let stored = store
|
|
.load::<Campaign>("campaign.v1", &campaign_id.to_string())
|
|
.unwrap()
|
|
.unwrap()
|
|
.1;
|
|
assert_eq!(stored.revision, 0);
|
|
assert!(stored.civic_systems.is_empty());
|
|
assert!(stored.institutions.is_empty());
|
|
}
|
|
|
|
#[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.clone());
|
|
let mut seed = campaign();
|
|
seed.locations.insert(
|
|
"away".into(),
|
|
Location {
|
|
id: "away".into(),
|
|
name: "Away".into(),
|
|
container_id: None,
|
|
routes: BTreeMap::new(),
|
|
persistent_features: vec![],
|
|
},
|
|
);
|
|
seed.actors.get_mut("player").unwrap().location_id = "away".into();
|
|
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![],
|
|
},
|
|
);
|
|
let gestalt_baseline = seed.gestalts["village"].clone();
|
|
crate::resolution::ensure_agency_profiles(&mut seed);
|
|
let demand = crate::resolution::default_demand(&seed, "pre-materialization cover");
|
|
seed.resolution_cover = Some(crate::resolution::plan_cover(&seed, demand).unwrap());
|
|
let john = 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,
|
|
last_relevant_revision: 0,
|
|
relevance_lease_until_revision: 0,
|
|
};
|
|
kernel
|
|
.command(WorldCommand::CreateCampaign {
|
|
campaign: seed,
|
|
evidence_receipts: vec![],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let first = kernel
|
|
.command(WorldCommand::IndividuateGestaltMember {
|
|
expected_revision: 0,
|
|
individuation: GestaltIndividuation {
|
|
gestalt_id: "village".into(),
|
|
expected_gestalt_version: 0,
|
|
member: john,
|
|
location_id: "room".into(),
|
|
},
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let CommandResult::Committed {
|
|
campaign: first, ..
|
|
} = first
|
|
else {
|
|
panic!()
|
|
};
|
|
assert!(
|
|
first.actors["member:john"]
|
|
.capabilities
|
|
.contains("master blacksmith")
|
|
);
|
|
assert_eq!(first.resolution_policy.resolution_epoch, 1);
|
|
assert!(first.resolution_cover.is_none());
|
|
assert!(
|
|
kernel
|
|
.command(WorldCommand::DematerializeGestaltMember {
|
|
expected_revision: 1,
|
|
actor_id: "member:john".into(),
|
|
})
|
|
.await
|
|
.unwrap_err()
|
|
.to_string()
|
|
.contains("lease")
|
|
);
|
|
kernel
|
|
.command(WorldCommand::Wait {
|
|
expected_revision: 1,
|
|
minutes: 1,
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let folded = kernel
|
|
.command(WorldCommand::DematerializeGestaltMember {
|
|
expected_revision: 2,
|
|
actor_id: "member:john".into(),
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let CommandResult::Committed {
|
|
campaign: folded, ..
|
|
} = folded
|
|
else {
|
|
panic!()
|
|
};
|
|
assert!(!folded.actors.contains_key("member:john"));
|
|
assert_eq!(folded.resolution_policy.resolution_epoch, 2);
|
|
assert!(folded.resolution_cover.is_none());
|
|
assert_eq!(
|
|
folded.gestalt_members["john"].memories,
|
|
vec!["met the player"]
|
|
);
|
|
let again = kernel
|
|
.command(WorldCommand::MaterializeGestaltMember {
|
|
expected_revision: 3,
|
|
gestalt_id: "village".into(),
|
|
expected_gestalt_version: 0,
|
|
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_eq!(again.gestalts["village"], gestalt_baseline);
|
|
assert_eq!(again.resolution_policy.resolution_epoch, 3);
|
|
assert!(again.resolution_cover.is_none());
|
|
|
|
let bad_plan = GestaltPresencePlan {
|
|
individuations: vec![],
|
|
demotions: vec![GestaltDemotion {
|
|
actor_id: "member:john".into(),
|
|
}],
|
|
promotions: vec![GestaltPromotion {
|
|
gestalt_id: "village".into(),
|
|
expected_gestalt_version: 0,
|
|
member_id: "invented-person".into(),
|
|
expected_member_version: 0,
|
|
location_id: "room".into(),
|
|
}],
|
|
};
|
|
assert!(
|
|
kernel
|
|
.command(WorldCommand::ReconcileGestaltPresence {
|
|
expected_revision: 4,
|
|
reason: "scene relevance changed".into(),
|
|
plan: bad_plan,
|
|
})
|
|
.await
|
|
.is_err()
|
|
);
|
|
let persisted = store
|
|
.load::<Campaign>("campaign.v1", &again.id.to_string())
|
|
.unwrap()
|
|
.unwrap()
|
|
.1;
|
|
assert_eq!(persisted.revision, 4);
|
|
assert!(persisted.actors.contains_key("member:john"));
|
|
assert_eq!(
|
|
persisted.gestalt_members["john"]
|
|
.materialized_actor_id
|
|
.as_deref(),
|
|
Some("member:john")
|
|
);
|
|
let receipts = store
|
|
.load_all::<crate::domain::GestaltMaterializationReceipt>(
|
|
"gestalt_materialization_receipt.v1",
|
|
)
|
|
.unwrap();
|
|
assert_eq!(receipts.len(), 3);
|
|
assert_eq!(receipts[0].changes[0].operation, "materialized");
|
|
assert_eq!(receipts[1].changes[0].operation, "dematerialized");
|
|
assert_eq!(receipts[2].changes[0].member_id, "john");
|
|
assert_eq!(receipts[0].previous_resolution_epoch, 0);
|
|
assert_eq!(receipts[0].resolution_epoch, 1);
|
|
assert_eq!(receipts[1].resolution_epoch, 2);
|
|
assert_eq!(receipts[2].resolution_epoch, 3);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn directly_addressed_persona_must_commit_an_observable_response() {
|
|
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.actors.insert(
|
|
"anna".into(),
|
|
ActorState {
|
|
id: "anna".into(),
|
|
name: "Anna".into(),
|
|
location_id: "room".into(),
|
|
capabilities: BTreeSet::new(),
|
|
knowledge: BTreeSet::new(),
|
|
equipment: BTreeSet::new(),
|
|
conditions: BTreeSet::new(),
|
|
obligations: BTreeSet::new(),
|
|
relationships: BTreeMap::new(),
|
|
goals: vec![],
|
|
memories: vec![],
|
|
},
|
|
);
|
|
seed.transcript.push(NarrativeTurn {
|
|
revision: 0,
|
|
at: seed.world_time,
|
|
speaker: "player".into(),
|
|
text: "Anna, answer me.".into(),
|
|
persona_response_actor_ids: BTreeSet::from(["anna".into()]),
|
|
});
|
|
kernel
|
|
.command(WorldCommand::CreateCampaign {
|
|
campaign: seed.clone(),
|
|
evidence_receipts: vec![],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
|
|
let silent = ActorReaction {
|
|
actor_id: "anna".into(),
|
|
speech: None,
|
|
deliberate_silence: false,
|
|
private_delta: ActorStateDelta::default(),
|
|
action_proposals: vec![],
|
|
};
|
|
let error = kernel
|
|
.command(WorldCommand::ResolveReactionWave {
|
|
expected_revision: 0,
|
|
event_summary: "player says: Anna, answer me.".into(),
|
|
reactions: vec![silent],
|
|
gestalt_reactions: vec![],
|
|
})
|
|
.await
|
|
.unwrap_err();
|
|
assert!(error.to_string().contains("no observable response"));
|
|
assert_eq!(
|
|
store
|
|
.load::<Campaign>("campaign.v1", &seed.id.to_string())
|
|
.unwrap()
|
|
.unwrap()
|
|
.1
|
|
.revision,
|
|
0
|
|
);
|
|
|
|
let committed = kernel
|
|
.command(WorldCommand::ResolveReactionWave {
|
|
expected_revision: 0,
|
|
event_summary: "player says: Anna, answer me.".into(),
|
|
reactions: vec![ActorReaction {
|
|
actor_id: "anna".into(),
|
|
speech: None,
|
|
deliberate_silence: true,
|
|
private_delta: ActorStateDelta::default(),
|
|
action_proposals: vec![],
|
|
}],
|
|
gestalt_reactions: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let CommandResult::Committed { campaign, .. } = committed else {
|
|
panic!()
|
|
};
|
|
assert_eq!(campaign.revision, 1);
|
|
assert_eq!(
|
|
campaign.transcript.last().unwrap().text,
|
|
"deliberately does not answer."
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn directly_addressed_local_gestalt_reacts_as_its_exact_collective_subject() {
|
|
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.gestalts.insert(
|
|
"households".into(),
|
|
GestaltPersonaState {
|
|
schema: "ghostlight.gestalt_persona_state.v1".into(),
|
|
id: "households".into(),
|
|
name: "Settlement households".into(),
|
|
version: 0,
|
|
home_location_id: "room".into(),
|
|
shared_capabilities: BTreeSet::from(["collective refusal".into()]),
|
|
shared_knowledge: BTreeSet::from(["the slate omits five names".into()]),
|
|
resources: BTreeSet::new(),
|
|
goals: vec!["keep every household traceable".into()],
|
|
pressures: vec!["the convoy slate is closing".into()],
|
|
},
|
|
);
|
|
seed.transcript.push(NarrativeTurn {
|
|
revision: 0,
|
|
at: seed.world_time,
|
|
speaker: "player".into(),
|
|
text: "Households, will you refuse the slate?".into(),
|
|
persona_response_actor_ids: BTreeSet::from(["households".into()]),
|
|
});
|
|
kernel
|
|
.command(WorldCommand::CreateCampaign {
|
|
campaign: seed.clone(),
|
|
evidence_receipts: vec![],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
|
|
let missing = kernel
|
|
.command(WorldCommand::ResolveReactionWave {
|
|
expected_revision: 0,
|
|
event_summary: "player says: Households, will you refuse the slate?".into(),
|
|
reactions: vec![],
|
|
gestalt_reactions: vec![],
|
|
})
|
|
.await
|
|
.unwrap_err();
|
|
assert!(missing.to_string().contains("no observable response"));
|
|
|
|
let committed = kernel
|
|
.command(WorldCommand::ResolveReactionWave {
|
|
expected_revision: 0,
|
|
event_summary: "player says: Households, will you refuse the slate?".into(),
|
|
reactions: vec![],
|
|
gestalt_reactions: vec![GestaltReaction {
|
|
gestalt_id: "households".into(),
|
|
speech: Some(
|
|
"We will refuse a slate that leaves our names untraceable.".into(),
|
|
),
|
|
deliberate_silence: false,
|
|
}],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let CommandResult::Committed { campaign, .. } = committed else {
|
|
panic!()
|
|
};
|
|
assert_eq!(campaign.revision, 1);
|
|
assert_eq!(campaign.transcript.last().unwrap().speaker, "households");
|
|
assert_eq!(
|
|
campaign.events.last().unwrap().gestalt_ids,
|
|
vec!["households"]
|
|
);
|
|
assert_eq!(campaign.gestalts["households"], seed.gestalts["households"]);
|
|
}
|
|
|
|
#[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![],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let reactions = vec![
|
|
ActorReaction {
|
|
actor_id: "anna".into(),
|
|
speech: Some("I saw that.".into()),
|
|
deliberate_silence: false,
|
|
private_delta: ActorStateDelta {
|
|
memories_add: vec!["saw the event".into()],
|
|
..Default::default()
|
|
},
|
|
action_proposals: vec![],
|
|
},
|
|
ActorReaction {
|
|
actor_id: "bert".into(),
|
|
speech: None,
|
|
deliberate_silence: false,
|
|
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,
|
|
gestalt_reactions: vec![],
|
|
})
|
|
.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());
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn reaction_interpreter_cannot_write_actor_memory() {
|
|
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.transcript.push(NarrativeTurn {
|
|
revision: 0,
|
|
at: seed.world_time,
|
|
speaker: "player".into(),
|
|
text: "Tell me which seal I repaired.".into(),
|
|
persona_response_actor_ids: BTreeSet::new(),
|
|
});
|
|
seed.actors.insert(
|
|
"anna".into(),
|
|
ActorState {
|
|
id: "anna".into(),
|
|
name: "Anna".into(),
|
|
location_id: "room".into(),
|
|
capabilities: BTreeSet::new(),
|
|
knowledge: BTreeSet::new(),
|
|
equipment: BTreeSet::new(),
|
|
conditions: BTreeSet::new(),
|
|
obligations: BTreeSet::new(),
|
|
relationships: BTreeMap::new(),
|
|
goals: vec![],
|
|
memories: vec![],
|
|
},
|
|
);
|
|
seed.actors.insert(
|
|
"taren".into(),
|
|
ActorState {
|
|
id: "taren".into(),
|
|
name: "Taren".into(),
|
|
location_id: "room".into(),
|
|
capabilities: BTreeSet::new(),
|
|
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![],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
|
|
let result = kernel
|
|
.command(WorldCommand::ResolveReactionWave {
|
|
expected_revision: 0,
|
|
event_summary: "player says: Tell me which seal I repaired.".into(),
|
|
reactions: vec![ActorReaction {
|
|
actor_id: "anna".into(),
|
|
speech: None,
|
|
deliberate_silence: false,
|
|
private_delta: ActorStateDelta {
|
|
memories_add: vec!["I repaired the seal.".into()],
|
|
..Default::default()
|
|
},
|
|
action_proposals: vec![],
|
|
}],
|
|
gestalt_reactions: vec![],
|
|
})
|
|
.await;
|
|
assert!(
|
|
matches!(result, Err(KernelError::Invalid(message)) if message.contains("cannot write actor memory"))
|
|
);
|
|
let identity_result = kernel
|
|
.command(WorldCommand::ResolveReactionWave {
|
|
expected_revision: 0,
|
|
event_summary: "player says: Tell me which seal I repaired.".into(),
|
|
reactions: vec![ActorReaction {
|
|
actor_id: "anna".into(),
|
|
speech: Some("My name is Anna.".into()),
|
|
deliberate_silence: false,
|
|
private_delta: ActorStateDelta {
|
|
identity_adoption: Some("Taren".into()),
|
|
..Default::default()
|
|
},
|
|
action_proposals: vec![],
|
|
}],
|
|
gestalt_reactions: vec![],
|
|
})
|
|
.await;
|
|
assert!(
|
|
matches!(identity_result, Err(KernelError::Invalid(message)) if message.contains("exact spoken handle"))
|
|
);
|
|
let conflicting_identity_result = kernel
|
|
.command(WorldCommand::ResolveReactionWave {
|
|
expected_revision: 0,
|
|
event_summary: "player says: Tell me which seal I repaired.".into(),
|
|
reactions: vec![ActorReaction {
|
|
actor_id: "anna".into(),
|
|
speech: Some("My name is Taren.".into()),
|
|
deliberate_silence: false,
|
|
private_delta: ActorStateDelta {
|
|
identity_adoption: Some("Taren".into()),
|
|
..Default::default()
|
|
},
|
|
action_proposals: vec![],
|
|
}],
|
|
gestalt_reactions: vec![],
|
|
})
|
|
.await;
|
|
assert!(
|
|
matches!(conflicting_identity_result, Err(KernelError::Invalid(message)) if message.contains("established local or population identity"))
|
|
);
|
|
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());
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn reaction_memory_preserves_exact_committed_speaker_attribution() {
|
|
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.transcript.push(NarrativeTurn {
|
|
revision: 0,
|
|
at: seed.world_time,
|
|
speaker: "player".into(),
|
|
text: "Tell me which seal I repaired.".into(),
|
|
persona_response_actor_ids: BTreeSet::new(),
|
|
});
|
|
seed.actors.insert(
|
|
"anna".into(),
|
|
ActorState {
|
|
id: "anna".into(),
|
|
name: "Anna".into(),
|
|
location_id: "room".into(),
|
|
capabilities: BTreeSet::new(),
|
|
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![],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
|
|
kernel
|
|
.command(WorldCommand::ResolveReactionWave {
|
|
expected_revision: 0,
|
|
event_summary: "player says: Tell me which seal I repaired.".into(),
|
|
reactions: vec![ActorReaction {
|
|
actor_id: "anna".into(),
|
|
speech: Some("I did not witness it.".into()),
|
|
deliberate_silence: false,
|
|
private_delta: ActorStateDelta::default(),
|
|
action_proposals: vec![],
|
|
}],
|
|
gestalt_reactions: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let persisted = store
|
|
.load::<Campaign>("campaign.v1", &seed.id.to_string())
|
|
.unwrap()
|
|
.unwrap()
|
|
.1;
|
|
assert_eq!(
|
|
persisted.actors["anna"].memories,
|
|
vec!["Witnessed: player says: Tell me which seal I repaired."]
|
|
);
|
|
assert!(!persisted.actors["anna"].memories[0].contains("Anna repaired"));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn initiative_grants_one_npc_opportunity_without_faking_player_activity() {
|
|
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.transcript.push(NarrativeTurn {
|
|
revision: 0,
|
|
at: seed.world_time,
|
|
speaker: "world".into(),
|
|
text: "a disturbance".into(),
|
|
persona_response_actor_ids: BTreeSet::new(),
|
|
});
|
|
seed.last_player_activity = Utc::now() - Duration::hours(2);
|
|
for id in ["anna", "bert"] {
|
|
seed.actors.insert(
|
|
id.into(),
|
|
ActorState {
|
|
id: id.into(),
|
|
name: id.into(),
|
|
location_id: "room".into(),
|
|
capabilities: BTreeSet::from(["intervene".into()]),
|
|
knowledge: BTreeSet::new(),
|
|
equipment: BTreeSet::new(),
|
|
conditions: BTreeSet::new(),
|
|
obligations: BTreeSet::new(),
|
|
relationships: BTreeMap::new(),
|
|
goals: vec![],
|
|
memories: vec![],
|
|
},
|
|
);
|
|
}
|
|
let activity = seed.last_player_activity;
|
|
let campaign_id = seed.id;
|
|
kernel
|
|
.command(WorldCommand::CreateCampaign {
|
|
campaign: seed,
|
|
evidence_receipts: vec![],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let proposal = |actor: &str, priority| WorldActionProposal {
|
|
actor_id: actor.into(),
|
|
intent: "intervene".into(),
|
|
intended_effect: "take control of the immediate situation".into(),
|
|
priority,
|
|
state_references: vec!["capability:intervene".into(), "location:room".into()],
|
|
};
|
|
let anna = proposal("anna", 9);
|
|
let bert = proposal("bert", 4);
|
|
let wave = kernel
|
|
.command(WorldCommand::ResolveReactionWave {
|
|
expected_revision: 0,
|
|
event_summary: "a disturbance".into(),
|
|
reactions: vec![
|
|
ActorReaction {
|
|
actor_id: "anna".into(),
|
|
speech: None,
|
|
deliberate_silence: false,
|
|
private_delta: ActorStateDelta::default(),
|
|
action_proposals: vec![anna.clone()],
|
|
},
|
|
ActorReaction {
|
|
actor_id: "bert".into(),
|
|
speech: None,
|
|
deliberate_silence: false,
|
|
private_delta: ActorStateDelta::default(),
|
|
action_proposals: vec![bert.clone()],
|
|
},
|
|
],
|
|
gestalt_reactions: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let assessment_for = |actor: &str| ActionIntent {
|
|
actor_id: actor.into(),
|
|
description: "intervene".into(),
|
|
intended_effect: "take control of the immediate situation".into(),
|
|
};
|
|
let CommandResult::Assessed {
|
|
assessment: bert_assessment,
|
|
} = kernel
|
|
.command(WorldCommand::Assess {
|
|
expected_revision: 1,
|
|
intent: assessment_for("bert"),
|
|
proposal: None,
|
|
})
|
|
.await
|
|
.unwrap()
|
|
else {
|
|
panic!()
|
|
};
|
|
assert!(
|
|
kernel
|
|
.command(WorldCommand::ResolveNpcAction {
|
|
expected_revision: 1,
|
|
proposal: bert,
|
|
assessment: bert_assessment,
|
|
})
|
|
.await
|
|
.is_err()
|
|
);
|
|
let CommandResult::Assessed { assessment } = kernel
|
|
.command(WorldCommand::Assess {
|
|
expected_revision: 1,
|
|
intent: assessment_for("anna"),
|
|
proposal: None,
|
|
})
|
|
.await
|
|
.unwrap()
|
|
else {
|
|
panic!()
|
|
};
|
|
let mut malformed = assessment.clone();
|
|
malformed
|
|
.success_effect
|
|
.actor_conditions
|
|
.insert("invented-actor".into(), ConditionDelta::default());
|
|
malformed.digest = crate::assessor::assessment_digest(&malformed).unwrap();
|
|
assert!(
|
|
kernel
|
|
.command(WorldCommand::ResolveNpcAction {
|
|
expected_revision: 1,
|
|
proposal: anna.clone(),
|
|
assessment: malformed,
|
|
})
|
|
.await
|
|
.is_err()
|
|
);
|
|
let unchanged = store
|
|
.load::<Campaign>("campaign.v1", &campaign_id.to_string())
|
|
.unwrap()
|
|
.unwrap()
|
|
.1;
|
|
assert_eq!(unchanged.revision, 1);
|
|
assert_eq!(unchanged.pending_world_proposals.len(), 2);
|
|
let resolved = kernel
|
|
.command(WorldCommand::ResolveNpcAction {
|
|
expected_revision: 1,
|
|
proposal: anna,
|
|
assessment,
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let CommandResult::Committed {
|
|
campaign: resolved, ..
|
|
} = resolved
|
|
else {
|
|
panic!()
|
|
};
|
|
assert!(resolved.pending_world_proposals.is_empty());
|
|
let persisted = store
|
|
.load::<Campaign>("campaign.v1", &resolved.id.to_string())
|
|
.unwrap()
|
|
.unwrap()
|
|
.1;
|
|
assert_eq!(persisted.last_player_activity, activity);
|
|
assert_eq!(persisted.revision, 2);
|
|
let CommandResult::Committed { campaign, .. } = wave else {
|
|
panic!()
|
|
};
|
|
assert_eq!(campaign.pending_world_proposals.len(), 2);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn npc_initiative_cannot_rebase_across_a_new_foreground_revision() {
|
|
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.transcript.push(NarrativeTurn {
|
|
revision: 0,
|
|
at: seed.world_time,
|
|
speaker: "world".into(),
|
|
text: "a disturbance".into(),
|
|
persona_response_actor_ids: BTreeSet::new(),
|
|
});
|
|
seed.actors.insert(
|
|
"anna".into(),
|
|
ActorState {
|
|
id: "anna".into(),
|
|
name: "Anna".into(),
|
|
location_id: "room".into(),
|
|
capabilities: BTreeSet::from(["intervene".into()]),
|
|
knowledge: BTreeSet::new(),
|
|
equipment: BTreeSet::new(),
|
|
conditions: BTreeSet::new(),
|
|
obligations: BTreeSet::new(),
|
|
relationships: BTreeMap::new(),
|
|
goals: vec![],
|
|
memories: vec![],
|
|
},
|
|
);
|
|
let campaign_id = seed.id;
|
|
kernel
|
|
.command(WorldCommand::CreateCampaign {
|
|
campaign: seed,
|
|
evidence_receipts: vec![],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let proposal = WorldActionProposal {
|
|
actor_id: "anna".into(),
|
|
intent: "intervene".into(),
|
|
intended_effect: "take control of the immediate situation".into(),
|
|
priority: 9,
|
|
state_references: vec!["capability:intervene".into(), "location:room".into()],
|
|
};
|
|
kernel
|
|
.command(WorldCommand::ResolveReactionWave {
|
|
expected_revision: 0,
|
|
event_summary: "a disturbance".into(),
|
|
reactions: vec![ActorReaction {
|
|
actor_id: "anna".into(),
|
|
speech: None,
|
|
deliberate_silence: false,
|
|
private_delta: ActorStateDelta::default(),
|
|
action_proposals: vec![proposal.clone()],
|
|
}],
|
|
gestalt_reactions: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
kernel
|
|
.command(WorldCommand::Speak {
|
|
expected_revision: 1,
|
|
actor_id: "player".into(),
|
|
text: "I move on before Anna acts.".into(),
|
|
intended_effect: None,
|
|
persona_response_actor_ids: BTreeSet::new(),
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let intent = ActionIntent {
|
|
actor_id: "anna".into(),
|
|
description: proposal.intent.clone(),
|
|
intended_effect: proposal.intended_effect.clone(),
|
|
};
|
|
let CommandResult::Assessed { assessment } = kernel
|
|
.command(WorldCommand::Assess {
|
|
expected_revision: 2,
|
|
intent,
|
|
proposal: None,
|
|
})
|
|
.await
|
|
.unwrap()
|
|
else {
|
|
panic!()
|
|
};
|
|
let error = kernel
|
|
.command(WorldCommand::ResolveNpcAction {
|
|
expected_revision: 2,
|
|
proposal,
|
|
assessment,
|
|
})
|
|
.await
|
|
.unwrap_err();
|
|
assert!(error.to_string().contains("current reaction wave"));
|
|
|
|
let refreshed = kernel
|
|
.command(WorldCommand::ResolveReactionWave {
|
|
expected_revision: 2,
|
|
event_summary: "player says: I move on before Anna acts.".into(),
|
|
reactions: vec![ActorReaction {
|
|
actor_id: "anna".into(),
|
|
speech: None,
|
|
deliberate_silence: false,
|
|
private_delta: ActorStateDelta::default(),
|
|
action_proposals: vec![],
|
|
}],
|
|
gestalt_reactions: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let CommandResult::Committed { campaign, .. } = refreshed else {
|
|
panic!()
|
|
};
|
|
assert_eq!(campaign.revision, 3);
|
|
assert!(campaign.pending_world_proposals.is_empty());
|
|
let persisted = store
|
|
.load::<Campaign>("campaign.v1", &campaign_id.to_string())
|
|
.unwrap()
|
|
.unwrap()
|
|
.1;
|
|
assert!(persisted.pending_world_proposals.is_empty());
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn roll_commits_only_the_prevalidated_typed_outcome_delta() {
|
|
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();
|
|
let player_location = seed.actors["player"].location_id.clone();
|
|
seed.facts.insert(
|
|
"fact:door-brace-seated".into(),
|
|
WorldFact {
|
|
id: "fact:door-brace-seated".into(),
|
|
statement: "The door brace is seated against the frame.".into(),
|
|
scope: FactScope::BranchLocal,
|
|
evidence_receipt_ids: vec![],
|
|
discoverable_at_location_ids: BTreeSet::from([player_location]),
|
|
},
|
|
);
|
|
let campaign_id = seed.id;
|
|
kernel
|
|
.command(WorldCommand::CreateCampaign {
|
|
campaign: seed.clone(),
|
|
evidence_receipts: vec![],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let intent = ActionIntent {
|
|
actor_id: "player".into(),
|
|
description: "brace the door".into(),
|
|
intended_effect: "become braced".into(),
|
|
};
|
|
let mut invalid = assess(&seed, intent.clone());
|
|
invalid
|
|
.success_effect
|
|
.actor_moves
|
|
.insert("player".into(), "nowhere".into());
|
|
invalid.digest = crate::assessor::assessment_digest(&invalid).unwrap();
|
|
assert!(
|
|
kernel
|
|
.command(WorldCommand::Assess {
|
|
expected_revision: 0,
|
|
intent: intent.clone(),
|
|
proposal: Some(invalid),
|
|
})
|
|
.await
|
|
.is_err()
|
|
);
|
|
let mut hidden_finding = assess(&seed, intent.clone());
|
|
hidden_finding
|
|
.success_effect
|
|
.actor_knowledge_additions
|
|
.insert(
|
|
"player".into(),
|
|
BTreeSet::from(["The hidden latch is broken.".into()]),
|
|
);
|
|
hidden_finding.success_stake = "The hidden latch is broken.".into();
|
|
hidden_finding.digest = crate::assessor::assessment_digest(&hidden_finding).unwrap();
|
|
assert!(
|
|
kernel
|
|
.command(WorldCommand::Assess {
|
|
expected_revision: 0,
|
|
intent: intent.clone(),
|
|
proposal: Some(hidden_finding),
|
|
})
|
|
.await
|
|
.is_err()
|
|
);
|
|
let delta = WorldEffectDelta {
|
|
actor_conditions: BTreeMap::from([(
|
|
"player".into(),
|
|
ConditionDelta {
|
|
add: BTreeSet::from(["braced".into()]),
|
|
remove: BTreeSet::new(),
|
|
},
|
|
)]),
|
|
actor_knowledge_additions: BTreeMap::from([(
|
|
"player".into(),
|
|
BTreeSet::from(["The door brace is seated against the frame.".into()]),
|
|
)]),
|
|
..Default::default()
|
|
};
|
|
let mut valid = assess(&seed, intent.clone());
|
|
valid.success_stake =
|
|
"The door brace is seated against the frame. You become braced.".into();
|
|
valid.mixed_stake = valid.success_stake.clone();
|
|
valid.failure_stake = valid.success_stake.clone();
|
|
valid.strong_effect = delta.clone();
|
|
valid.success_effect = delta.clone();
|
|
valid.mixed_effect = delta.clone();
|
|
valid.failure_effect = delta;
|
|
valid.digest = crate::assessor::assessment_digest(&valid).unwrap();
|
|
kernel
|
|
.command(WorldCommand::Assess {
|
|
expected_revision: 0,
|
|
intent,
|
|
proposal: Some(valid.clone()),
|
|
})
|
|
.await
|
|
.unwrap();
|
|
kernel
|
|
.command(WorldCommand::Attempt {
|
|
actor_id: "player".into(),
|
|
assessment_digest: valid.digest,
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let persisted = store
|
|
.load::<Campaign>("campaign.v1", &campaign_id.to_string())
|
|
.unwrap()
|
|
.unwrap()
|
|
.1;
|
|
assert_eq!(persisted.revision, 1);
|
|
assert!(persisted.actors["player"].conditions.contains("braced"));
|
|
assert!(
|
|
persisted.actors["player"]
|
|
.knowledge
|
|
.contains("The door brace is seated against the frame.")
|
|
);
|
|
assert!(persisted.facts.values().any(|fact| {
|
|
fact.statement == "The door brace is seated against the frame."
|
|
&& fact.scope == FactScope::BranchLocal
|
|
}));
|
|
assert_eq!(persisted.facts.len(), 1);
|
|
}
|
|
|
|
#[test]
|
|
fn information_effects_reveal_existing_accessible_facts_only() {
|
|
let statement = "The maintenance panel records a seven-minute interruption.";
|
|
let mut seed = campaign();
|
|
seed.facts.insert(
|
|
"fact:panel-interruption".into(),
|
|
WorldFact {
|
|
id: "fact:panel-interruption".into(),
|
|
statement: statement.into(),
|
|
scope: FactScope::BranchLocal,
|
|
evidence_receipt_ids: vec![],
|
|
discoverable_at_location_ids: BTreeSet::from(["room".into()]),
|
|
},
|
|
);
|
|
let effect = WorldEffectDelta {
|
|
actor_knowledge_additions: BTreeMap::from([(
|
|
"player".into(),
|
|
BTreeSet::from([statement.into()]),
|
|
)]),
|
|
..Default::default()
|
|
};
|
|
assert!(
|
|
crate::assessor::validate_effect(&seed, &seed.actors["player"], &effect, statement,)
|
|
.is_ok()
|
|
);
|
|
|
|
let mut absent = seed.clone();
|
|
absent.facts.clear();
|
|
assert!(
|
|
crate::assessor::validate_effect(
|
|
&absent,
|
|
&absent.actors["player"],
|
|
&effect,
|
|
statement,
|
|
)
|
|
.unwrap_err()
|
|
.to_string()
|
|
.contains("existing accessible WorldFact")
|
|
);
|
|
|
|
let mut wrong_place = seed.clone();
|
|
wrong_place
|
|
.facts
|
|
.get_mut("fact:panel-interruption")
|
|
.unwrap()
|
|
.discoverable_at_location_ids = BTreeSet::from(["elsewhere".into()]);
|
|
assert!(
|
|
crate::assessor::validate_effect(
|
|
&wrong_place,
|
|
&wrong_place.actors["player"],
|
|
&effect,
|
|
statement,
|
|
)
|
|
.is_err()
|
|
);
|
|
|
|
let mut speaker = seed.actors["player"].clone();
|
|
speaker.id = "speaker".into();
|
|
speaker.name = "Speaker".into();
|
|
speaker.knowledge.insert(statement.into());
|
|
seed.actors.insert(speaker.id.clone(), speaker.clone());
|
|
seed.facts
|
|
.get_mut("fact:panel-interruption")
|
|
.unwrap()
|
|
.discoverable_at_location_ids
|
|
.clear();
|
|
assert!(
|
|
crate::assessor::validate_effect(&seed, &speaker, &effect, statement).is_ok(),
|
|
"an actor may communicate an existing fact they know to another present actor"
|
|
);
|
|
}
|
|
|
|
fn resolution_stage(
|
|
cell_id: &str,
|
|
campaign: &Campaign,
|
|
stage: &str,
|
|
marker: char,
|
|
) -> crate::model::ModelStageReceipt {
|
|
let hash = test_action_digest(&format!(
|
|
"resolution-stage:{}:{}:{}:{}:{}",
|
|
campaign.id, campaign.revision, cell_id, stage, marker
|
|
));
|
|
crate::model::ModelStageReceipt {
|
|
schema: "ghostlight.persona_stage_receipt.v1".into(),
|
|
receipt_hash: hash.clone(),
|
|
provider: "fixture".into(),
|
|
model: "fixture".into(),
|
|
stage: stage.into(),
|
|
snapshot_binding: format!(
|
|
"campaign:{}:revision:{}:resolution:{}:cell:{}",
|
|
campaign.id,
|
|
campaign.revision,
|
|
campaign.resolution_policy.resolution_epoch,
|
|
cell_id
|
|
),
|
|
request_hash: format!("sha256:{}", "e".repeat(64)),
|
|
output_hash: format!("sha256:{}", "f".repeat(64)),
|
|
source_receipt_ids: vec![],
|
|
latency_ms: 1,
|
|
validation_result: "valid".into(),
|
|
local_validation_error: None,
|
|
input_chars: 7,
|
|
output_chars: 7,
|
|
provider_attempts: vec![],
|
|
}
|
|
}
|
|
|
|
fn inaction_wave(
|
|
campaign: &Campaign,
|
|
store: &CampaignStore,
|
|
) -> crate::domain::ResolutionWaveCommit {
|
|
let cover = crate::resolution::plan_cover(
|
|
campaign,
|
|
crate::resolution::default_demand(campaign, "kernel fixture"),
|
|
)
|
|
.unwrap();
|
|
let mut hashes = Vec::new();
|
|
for (cell_index, cell) in cover.cells.iter().enumerate() {
|
|
for (stage_index, stage) in ["cell_projector", "cell_persona", "cell_interpreter"]
|
|
.into_iter()
|
|
.enumerate()
|
|
{
|
|
let marker =
|
|
char::from_u32(u32::from(b'a') + (cell_index * 3 + stage_index) as u32)
|
|
.unwrap();
|
|
let receipt = resolution_stage(&cell.id, campaign, stage, marker);
|
|
store
|
|
.insert(
|
|
"persona_stage_receipt.v1",
|
|
"ghostlight.persona_stage_receipt.v1",
|
|
receipt.storage_key(),
|
|
&receipt,
|
|
)
|
|
.unwrap();
|
|
hashes.push(receipt.storage_key().to_owned());
|
|
}
|
|
}
|
|
crate::domain::ResolutionWaveCommit {
|
|
schema: "ghostlight.resolution_wave_commit.v1".into(),
|
|
world_revision: campaign.revision,
|
|
resolution_epoch: campaign.resolution_policy.resolution_epoch,
|
|
plan_receipt: crate::resolution::plan_receipt(campaign, &cover),
|
|
appraisals: cover
|
|
.cells
|
|
.iter()
|
|
.map(|cell| {
|
|
let decision_owner = cell
|
|
.detail_focus_subject_id
|
|
.as_ref()
|
|
.or_else(|| cell.subject_ids.iter().next())
|
|
.expect("a simulation cell has at least one subject")
|
|
.clone();
|
|
CellAppraisal {
|
|
schema: "ghostlight.cell_appraisal.v1".into(),
|
|
cell_id: cell.id.clone(),
|
|
world_revision: campaign.revision,
|
|
resolution_epoch: campaign.resolution_policy.resolution_epoch,
|
|
considered_subject_ids: BTreeSet::from([decision_owner.clone()]),
|
|
actions: vec![],
|
|
inactions: vec![crate::domain::CellInaction {
|
|
subject_id: decision_owner,
|
|
reason: "No justified move.".into(),
|
|
}],
|
|
}
|
|
})
|
|
.collect(),
|
|
cover,
|
|
activity_outcomes: vec![],
|
|
strategic_individuations: vec![],
|
|
model_receipt_hashes: hashes,
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn direct_strategic_plan_cannot_write_external_subject_state() {
|
|
let external = BTreeSet::from(["external-hold".to_string()]);
|
|
let mut plan = StrategicTickPlan::default();
|
|
plan.institution_actions.push(StrategicInstitutionAction {
|
|
institution_id: "external-hold".into(),
|
|
posture: "overwritten".into(),
|
|
location_ids: Vec::new(),
|
|
public_channels: Vec::new(),
|
|
});
|
|
assert!(strategic_plan_writes_external_subject(&plan, &external));
|
|
|
|
plan.institution_actions.clear();
|
|
plan.activity_outcomes.push(StrategicActivityOutcome {
|
|
schema: "ghostlight.strategic_activity_outcome.v1".into(),
|
|
action_digest: format!("sha256:{}", "a".repeat(64)),
|
|
source_subject_id: "foreign-court".into(),
|
|
band: StrategicOutcomeBand::Success,
|
|
summary: "Attempted cross-boundary resource mutation.".into(),
|
|
supporting_state_references: Vec::new(),
|
|
effect: StrategicOutcomeEffect::ResourceConsumed {
|
|
owner_subject_id: "external-hold".into(),
|
|
resource: "ore".into(),
|
|
},
|
|
});
|
|
assert!(strategic_plan_writes_external_subject(&plan, &external));
|
|
|
|
plan.activity_outcomes.clear();
|
|
plan.selected_actions.push(CellActionProposal {
|
|
subject_id: "foreign-court".into(),
|
|
intent: "Contact the hold.".into(),
|
|
intended_effect: "Request negotiation.".into(),
|
|
priority: 1,
|
|
state_references: Vec::new(),
|
|
public_channels: Vec::new(),
|
|
effects: vec![StrategicCellEffect::ActorActivity {
|
|
actor_id: "foreign-court".into(),
|
|
activity: StrategicActivityKind::Communicate,
|
|
target_subject_ids: vec!["external-hold".into()],
|
|
location_ids: Vec::new(),
|
|
}],
|
|
});
|
|
assert!(strategic_plan_writes_external_subject(&plan, &external));
|
|
}
|
|
|
|
#[test]
|
|
fn strategic_wave_derives_attributed_external_proposal() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let store = CampaignStore::open(dir.path().join("campaign.cc")).unwrap();
|
|
let campaign = crate::resolution::tests::campaign(2, 2);
|
|
let mut wave = inaction_wave(&campaign, &store);
|
|
let appraisal = wave.appraisals.first_mut().unwrap();
|
|
let source_subject_id = appraisal.inactions[0].subject_id.clone();
|
|
appraisal.inactions.clear();
|
|
appraisal.actions.push(CellActionProposal {
|
|
subject_id: source_subject_id.clone(),
|
|
intent: "Open talks with the external hold.".into(),
|
|
intended_effect: "Establish a negotiating channel.".into(),
|
|
priority: 1,
|
|
state_references: Vec::new(),
|
|
public_channels: vec!["diplomatic".into()],
|
|
effects: vec![StrategicCellEffect::ActorActivity {
|
|
actor_id: source_subject_id.clone(),
|
|
activity: StrategicActivityKind::Communicate,
|
|
target_subject_ids: vec!["external-hold".into()],
|
|
location_ids: Vec::new(),
|
|
}],
|
|
});
|
|
let authorities = vec![crate::consumer::ExternalSubjectAuthority {
|
|
schema: "ghostlight.external_subject_authority.v1".into(),
|
|
id: "authority:external-hold".into(),
|
|
campaign_id: campaign.id,
|
|
subject_id: "external-hold".into(),
|
|
subject_kind: AgencySubjectKind::Institution,
|
|
owner_id: "fixture-consumer".into(),
|
|
authority_key_sha256: crate::consumer::authority_key_digest("secret"),
|
|
last_source_revision: None,
|
|
last_payload_digest: None,
|
|
}];
|
|
let proposals =
|
|
external_proposals_for_wave(campaign.id, 1, Utc::now(), &wave, &authorities).unwrap();
|
|
assert_eq!(proposals.len(), 1);
|
|
assert_eq!(proposals[0].source_subject_id, source_subject_id);
|
|
assert_eq!(proposals[0].external_subject_id, "external-hold");
|
|
assert_eq!(proposals[0].authority_id, "authority:external-hold");
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn resolution_budget_commits_without_advancing_fictional_state() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let store = CampaignStore::open(dir.path().join("campaign.cc")).unwrap();
|
|
let kernel = WorldKernel::start(store.clone());
|
|
let seed = crate::resolution::tests::campaign(6, 8);
|
|
let world_time = seed.world_time;
|
|
kernel
|
|
.command(WorldCommand::CreateCampaign {
|
|
campaign: seed.clone(),
|
|
evidence_receipts: vec![],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let result = kernel
|
|
.command(WorldCommand::SetResolutionBudget {
|
|
expected_revision: 0,
|
|
expected_resolution_epoch: 0,
|
|
active_cell_budget: 3,
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let CommandResult::ResolutionUpdated { campaign, receipt } = result else {
|
|
panic!("resolution command used the world commit path")
|
|
};
|
|
assert_eq!(campaign.revision, 0);
|
|
assert_eq!(campaign.world_time, world_time);
|
|
assert_eq!(campaign.resolution_policy.active_cell_budget, 3);
|
|
assert_eq!(campaign.resolution_policy.resolution_epoch, 1);
|
|
assert_eq!(receipt.previous_resolution_epoch, 0);
|
|
let unchanged = kernel
|
|
.command(WorldCommand::SetResolutionBudget {
|
|
expected_revision: 0,
|
|
expected_resolution_epoch: 1,
|
|
active_cell_budget: 3,
|
|
})
|
|
.await
|
|
.unwrap_err();
|
|
assert!(unchanged.to_string().contains("does not change"));
|
|
assert!(
|
|
kernel
|
|
.command(WorldCommand::SetResolutionBudget {
|
|
expected_revision: 0,
|
|
expected_resolution_epoch: 0,
|
|
active_cell_budget: 4,
|
|
})
|
|
.await
|
|
.is_err()
|
|
);
|
|
assert_eq!(
|
|
store.keys("resolution_control_receipt.v1").unwrap().len(),
|
|
1
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn provider_parallelism_changes_without_repartitioning_the_world() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let store = CampaignStore::open(dir.path().join("campaign.cc")).unwrap();
|
|
let kernel = WorldKernel::start(store);
|
|
let mut seed = crate::resolution::tests::campaign(6, 3);
|
|
let cover = crate::resolution::plan_cover(
|
|
&seed,
|
|
crate::resolution::default_demand(&seed, "existing cover"),
|
|
)
|
|
.unwrap();
|
|
seed.resolution_cover = Some(cover.clone());
|
|
let world_time = seed.world_time;
|
|
kernel
|
|
.command(WorldCommand::CreateCampaign {
|
|
campaign: seed,
|
|
evidence_receipts: vec![],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let result = kernel
|
|
.command(WorldCommand::SetProviderParallelism {
|
|
expected_revision: 0,
|
|
expected_provider_configuration_epoch: 0,
|
|
provider_parallelism: 4,
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let CommandResult::ResolutionUpdated { campaign, receipt } = result else {
|
|
panic!("operator control used the fictional world commit path")
|
|
};
|
|
assert_eq!(campaign.revision, 0);
|
|
assert_eq!(campaign.world_time, world_time);
|
|
assert_eq!(campaign.resolution_policy.resolution_epoch, 0);
|
|
assert_eq!(campaign.resolution_policy.provider_configuration_epoch, 1);
|
|
assert_eq!(campaign.resolution_policy.provider_parallelism, 4);
|
|
assert_eq!(campaign.resolution_cover, Some(cover));
|
|
assert_eq!(receipt.operation, "set_provider_parallelism");
|
|
let unchanged = kernel
|
|
.command(WorldCommand::SetProviderParallelism {
|
|
expected_revision: 0,
|
|
expected_provider_configuration_epoch: 1,
|
|
provider_parallelism: 4,
|
|
})
|
|
.await
|
|
.unwrap_err();
|
|
assert!(unchanged.to_string().contains("does not change"));
|
|
assert!(
|
|
kernel
|
|
.command(WorldCommand::SetProviderParallelism {
|
|
expected_revision: 0,
|
|
expected_provider_configuration_epoch: 0,
|
|
provider_parallelism: 2,
|
|
})
|
|
.await
|
|
.is_err()
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn strategic_resolution_wave_commits_cover_and_all_appraisals_atomically() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let store = CampaignStore::open(dir.path().join("campaign.cc")).unwrap();
|
|
let kernel = WorldKernel::start(store.clone());
|
|
let seed = crate::resolution::tests::campaign(6, 2);
|
|
kernel
|
|
.command(WorldCommand::CreateCampaign {
|
|
campaign: seed.clone(),
|
|
evidence_receipts: vec![],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let persisted = store
|
|
.load::<Campaign>("campaign.v1", &seed.id.to_string())
|
|
.unwrap()
|
|
.unwrap()
|
|
.1;
|
|
let wave = inaction_wave(&persisted, &store);
|
|
let cell_count = wave.cover.cells.len();
|
|
let result = kernel
|
|
.command(WorldCommand::AdvanceStrategicTick {
|
|
expected_revision: 0,
|
|
source: TickSource::Scheduler,
|
|
plan: None,
|
|
model_receipt_hash: Some(format!("sha256:{}", "9".repeat(64))),
|
|
resolution_wave: Some(wave),
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let CommandResult::Committed { campaign, .. } = result else {
|
|
panic!()
|
|
};
|
|
assert_eq!(campaign.revision, 1);
|
|
assert_eq!(campaign.strategic_tick_count, 1);
|
|
assert!(campaign.resolution_cover.is_some());
|
|
assert_eq!(store.keys("cell_appraisal.v1").unwrap().len(), cell_count);
|
|
assert_eq!(store.keys("resolution_plan_receipt.v1").unwrap().len(), 1);
|
|
assert_eq!(store.keys("strategic_tick.v1").unwrap().len(), 1);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn invalid_effect_verifier_receipt_cannot_authorize_an_actionful_cell() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let store = CampaignStore::open(dir.path().join("campaign.cc")).unwrap();
|
|
let kernel = WorldKernel::start(store.clone());
|
|
let seed = crate::resolution::tests::campaign(3, 1);
|
|
kernel
|
|
.command(WorldCommand::CreateCampaign {
|
|
campaign: seed.clone(),
|
|
evidence_receipts: vec![],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let persisted = store
|
|
.load::<Campaign>("campaign.v1", &seed.id.to_string())
|
|
.unwrap()
|
|
.unwrap()
|
|
.1;
|
|
let mut wave = inaction_wave(&persisted, &store);
|
|
let subject_id = wave.cover.cells[0]
|
|
.subject_ids
|
|
.iter()
|
|
.next()
|
|
.unwrap()
|
|
.clone();
|
|
wave.appraisals[0].actions = vec![CellActionProposal {
|
|
subject_id: subject_id.clone(),
|
|
intent: "adopt a new position".into(),
|
|
intended_effect: "publish a different commitment".into(),
|
|
priority: 1,
|
|
state_references: vec![],
|
|
public_channels: vec![],
|
|
effects: vec![StrategicCellEffect::Institution {
|
|
institution_id: subject_id,
|
|
posture: "publishing a bounded new commitment".into(),
|
|
location_ids: vec![],
|
|
}],
|
|
}];
|
|
wave.appraisals[0].inactions.clear();
|
|
let mut rejected_verifier = resolution_stage(
|
|
&wave.cover.cells[0].id,
|
|
&persisted,
|
|
"cell_effect_verifier",
|
|
'd',
|
|
);
|
|
rejected_verifier.validation_result = "semantic_invalid".into();
|
|
rejected_verifier.local_validation_error =
|
|
Some("typed effect reverses the decision".into());
|
|
store
|
|
.insert(
|
|
"persona_stage_receipt.v1",
|
|
"ghostlight.persona_stage_receipt.v1",
|
|
rejected_verifier.storage_key(),
|
|
&rejected_verifier,
|
|
)
|
|
.unwrap();
|
|
wave.model_receipt_hashes
|
|
.push(rejected_verifier.storage_key().to_owned());
|
|
|
|
let error = kernel
|
|
.command(WorldCommand::AdvanceStrategicTick {
|
|
expected_revision: 0,
|
|
source: TickSource::Scheduler,
|
|
plan: None,
|
|
model_receipt_hash: Some(format!("sha256:{}", "9".repeat(64))),
|
|
resolution_wave: Some(wave),
|
|
})
|
|
.await
|
|
.unwrap_err();
|
|
assert!(
|
|
error
|
|
.to_string()
|
|
.contains("lacks action-bound cell_effect_verifier"),
|
|
"unexpected kernel rejection: {error}"
|
|
);
|
|
let stored = store
|
|
.load::<Campaign>("campaign.v1", &seed.id.to_string())
|
|
.unwrap()
|
|
.unwrap()
|
|
.1;
|
|
assert_eq!(stored.revision, 0);
|
|
assert_eq!(stored.world_time, seed.world_time);
|
|
}
|
|
|
|
#[test]
|
|
fn activity_outcome_receipts_bind_each_selected_action_independently() {
|
|
let value = hierarchical_refugee_campaign();
|
|
let first = format!("sha256:{}", "1".repeat(64));
|
|
let second = format!("sha256:{}", "2".repeat(64));
|
|
let bindings = expected_activity_outcome_bindings(&value, &[first.clone(), second.clone()]);
|
|
|
|
assert_eq!(bindings.len(), 2);
|
|
assert_eq!(
|
|
bindings[0],
|
|
crate::outcome::activity_outcome_binding(
|
|
value.id,
|
|
value.revision,
|
|
value.resolution_policy.resolution_epoch,
|
|
std::slice::from_ref(&first),
|
|
)
|
|
);
|
|
assert_eq!(
|
|
bindings[1],
|
|
crate::outcome::activity_outcome_binding(
|
|
value.id,
|
|
value.revision,
|
|
value.resolution_policy.resolution_epoch,
|
|
std::slice::from_ref(&second),
|
|
)
|
|
);
|
|
assert!(
|
|
!bindings.contains(&crate::outcome::activity_outcome_binding(
|
|
value.id,
|
|
value.revision,
|
|
value.resolution_policy.resolution_epoch,
|
|
&[first, second],
|
|
))
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn activity_outcome_receipt_must_bind_the_exact_selected_action() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let store = CampaignStore::open(dir.path().join("campaign.cc")).unwrap();
|
|
let kernel = WorldKernel::start(store.clone());
|
|
let seed = hierarchical_refugee_campaign();
|
|
kernel
|
|
.command(WorldCommand::CreateCampaign {
|
|
campaign: seed.clone(),
|
|
evidence_receipts: vec![],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let persisted = store
|
|
.load::<Campaign>("campaign.v1", &seed.id.to_string())
|
|
.unwrap()
|
|
.unwrap()
|
|
.1;
|
|
let mut wave = inaction_wave(&persisted, &store);
|
|
let refugees_cell_id = wave
|
|
.cover
|
|
.cells
|
|
.iter()
|
|
.find(|cell| cell.subject_ids.contains("refugees-east"))
|
|
.map(|cell| cell.id.clone())
|
|
.unwrap();
|
|
let appraisal = wave
|
|
.appraisals
|
|
.iter_mut()
|
|
.find(|appraisal| appraisal.cell_id == refugees_cell_id)
|
|
.unwrap();
|
|
appraisal.considered_subject_ids = BTreeSet::from(["refugees-east".into()]);
|
|
let proposal = CellActionProposal {
|
|
subject_id: "refugees-east".into(),
|
|
intent: "prepare storm lashings".into(),
|
|
intended_effect: "finish one bounded set of camp lashings".into(),
|
|
priority: 60,
|
|
state_references: vec![
|
|
"subject:refugees-east".into(),
|
|
"capability:survive transit".into(),
|
|
"location:camp".into(),
|
|
],
|
|
public_channels: vec![],
|
|
effects: vec![StrategicCellEffect::GestaltActivity {
|
|
gestalt_id: "refugees-east".into(),
|
|
activity: StrategicActivityKind::Prepare,
|
|
target_subject_ids: vec![],
|
|
location_ids: vec!["camp".into()],
|
|
}],
|
|
};
|
|
let action_digest = crate::resolution::cell_action_digest(&proposal).unwrap();
|
|
appraisal.actions = vec![proposal];
|
|
appraisal.inactions.clear();
|
|
let appraisal_cell_id = appraisal.cell_id.clone();
|
|
let appraisal_actions = appraisal.actions.clone();
|
|
wave.activity_outcomes = vec![StrategicActivityOutcome {
|
|
schema: "ghostlight.strategic_activity_outcome.v1".into(),
|
|
action_digest: action_digest.clone(),
|
|
source_subject_id: "refugees-east".into(),
|
|
band: StrategicOutcomeBand::Success,
|
|
summary: "The camp finishes one set of storm lashings.".into(),
|
|
supporting_state_references: vec!["capability:survive transit".into()],
|
|
effect: StrategicOutcomeEffect::ResourceCreated {
|
|
owner_subject_id: "refugees-east".into(),
|
|
resource: "storm lashings".into(),
|
|
},
|
|
}];
|
|
|
|
let base_binding = format!(
|
|
"campaign:{}:revision:{}:resolution:{}:cell:{}",
|
|
persisted.id,
|
|
persisted.revision,
|
|
persisted.resolution_policy.resolution_epoch,
|
|
appraisal_cell_id
|
|
);
|
|
let mut verifier =
|
|
resolution_stage(&appraisal_cell_id, &persisted, "cell_effect_verifier", '7');
|
|
verifier.snapshot_binding =
|
|
crate::persona::cell_effect_verification_binding(&base_binding, &appraisal_actions)
|
|
.unwrap();
|
|
let wrong_outcome = resolution_stage(
|
|
&appraisal_cell_id,
|
|
&persisted,
|
|
"strategic_outcome_resolver",
|
|
'8',
|
|
);
|
|
for receipt in [verifier, wrong_outcome] {
|
|
store
|
|
.insert(
|
|
"persona_stage_receipt.v1",
|
|
"ghostlight.persona_stage_receipt.v1",
|
|
receipt.storage_key(),
|
|
&receipt,
|
|
)
|
|
.unwrap();
|
|
wave.model_receipt_hashes
|
|
.push(receipt.storage_key().to_owned());
|
|
}
|
|
let mut correct_wave = wave.clone();
|
|
let mut correct_outcome = resolution_stage(
|
|
&appraisal_cell_id,
|
|
&persisted,
|
|
"strategic_outcome_resolver",
|
|
'9',
|
|
);
|
|
correct_outcome.snapshot_binding = crate::outcome::activity_outcome_binding(
|
|
persisted.id,
|
|
persisted.revision,
|
|
persisted.resolution_policy.resolution_epoch,
|
|
&[action_digest],
|
|
);
|
|
store
|
|
.insert(
|
|
"persona_stage_receipt.v1",
|
|
"ghostlight.persona_stage_receipt.v1",
|
|
correct_outcome.storage_key(),
|
|
&correct_outcome,
|
|
)
|
|
.unwrap();
|
|
correct_wave.model_receipt_hashes.pop();
|
|
correct_wave
|
|
.model_receipt_hashes
|
|
.push(correct_outcome.storage_key().to_owned());
|
|
|
|
let error = kernel
|
|
.command(WorldCommand::AdvanceStrategicTick {
|
|
expected_revision: 0,
|
|
source: TickSource::Scheduler,
|
|
plan: None,
|
|
model_receipt_hash: Some(format!("sha256:{}", "9".repeat(64))),
|
|
resolution_wave: Some(wave),
|
|
})
|
|
.await
|
|
.unwrap_err();
|
|
assert!(
|
|
error
|
|
.to_string()
|
|
.contains("lacks an activity-bound strategic outcome receipt"),
|
|
"unexpected kernel rejection: {error}"
|
|
);
|
|
let stored = store
|
|
.load::<Campaign>("campaign.v1", &seed.id.to_string())
|
|
.unwrap()
|
|
.unwrap()
|
|
.1;
|
|
assert_eq!(stored.revision, 0);
|
|
assert_eq!(stored.world_time, seed.world_time);
|
|
assert!(
|
|
!stored.gestalts["refugees-east"]
|
|
.resources
|
|
.contains("storm lashings")
|
|
);
|
|
|
|
let result = kernel
|
|
.command(WorldCommand::AdvanceStrategicTick {
|
|
expected_revision: 0,
|
|
source: TickSource::Scheduler,
|
|
plan: None,
|
|
model_receipt_hash: Some(format!("sha256:{}", "a".repeat(64))),
|
|
resolution_wave: Some(correct_wave),
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let CommandResult::Committed { campaign, .. } = result else {
|
|
panic!()
|
|
};
|
|
assert_eq!(campaign.revision, 1);
|
|
assert!(
|
|
campaign.gestalts["refugees-east"]
|
|
.resources
|
|
.contains("storm lashings")
|
|
);
|
|
assert_eq!(
|
|
store.keys("strategic_activity_outcome.v1").unwrap().len(),
|
|
1
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn strategic_wave_atomically_individuates_and_materializes_an_action_bound_person() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let store = CampaignStore::open(dir.path().join("campaign.cc")).unwrap();
|
|
let kernel = WorldKernel::start(store.clone());
|
|
let mut seed = hierarchical_refugee_campaign();
|
|
seed.agency_profiles
|
|
.get_mut("refugees-east")
|
|
.unwrap()
|
|
.information_channels
|
|
.insert("storm-camp broadsheet".into());
|
|
kernel
|
|
.command(WorldCommand::CreateCampaign {
|
|
campaign: seed.clone(),
|
|
evidence_receipts: vec![],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let persisted = store
|
|
.load::<Campaign>("campaign.v1", &seed.id.to_string())
|
|
.unwrap()
|
|
.unwrap()
|
|
.1;
|
|
let mut wave = inaction_wave(&persisted, &store);
|
|
let cell_id = wave
|
|
.cover
|
|
.cells
|
|
.iter()
|
|
.find(|cell| cell.subject_ids.contains("refugees-east"))
|
|
.unwrap()
|
|
.id
|
|
.clone();
|
|
let appraisal = wave
|
|
.appraisals
|
|
.iter_mut()
|
|
.find(|appraisal| appraisal.cell_id == cell_id)
|
|
.unwrap();
|
|
appraisal.considered_subject_ids = BTreeSet::from(["refugees-east".into()]);
|
|
let action = CellActionProposal {
|
|
subject_id: "refugees-east".into(),
|
|
intent: "appoint a named storm delegation broker".into(),
|
|
intended_effect: "make one accuser answer for the camp negotiation".into(),
|
|
priority: 80,
|
|
state_references: vec!["subject:refugees-east".into(), "location:camp".into()],
|
|
public_channels: vec!["storm-camp broadsheet".into()],
|
|
effects: vec![StrategicCellEffect::Gestalt {
|
|
gestalt_id: "refugees-east".into(),
|
|
pressure_additions: vec![
|
|
"Veska Rill says the east quartermasters sold the lower road twice".into(),
|
|
],
|
|
pressure_resolutions: vec![],
|
|
}],
|
|
};
|
|
let action_digest = crate::resolution::cell_action_digest(&action).unwrap();
|
|
appraisal.actions = vec![action.clone()];
|
|
appraisal.inactions.clear();
|
|
wave.strategic_individuations = vec![StrategicGestaltIndividuation {
|
|
schema: "ghostlight.strategic_gestalt_individuation.v1".into(),
|
|
action_digest: action_digest.clone(),
|
|
rationale:
|
|
"She accused the east quartermasters of selling the broken lower road twice.".into(),
|
|
individuation: GestaltIndividuation {
|
|
gestalt_id: "refugees-east".into(),
|
|
expected_gestalt_version: 0,
|
|
location_id: "camp".into(),
|
|
member: GestaltMemberDelta {
|
|
schema: "ghostlight.gestalt_member_delta.v1".into(),
|
|
id: "veska-rill".into(),
|
|
gestalt_id: "refugees-east".into(),
|
|
version: 0,
|
|
name: "Veska Rill".into(),
|
|
capability_additions: BTreeSet::new(),
|
|
capability_removals: BTreeSet::new(),
|
|
knowledge_additions: BTreeSet::new(),
|
|
knowledge_removals: BTreeSet::new(),
|
|
equipment: BTreeSet::new(),
|
|
conditions: BTreeSet::new(),
|
|
obligations: BTreeSet::from(["answer to the camp wards".into()]),
|
|
relationships: BTreeMap::new(),
|
|
goals: vec!["secure the storm route".into()],
|
|
memories: vec!["the deep excavation broke the lower road".into()],
|
|
last_location_id: Some("camp".into()),
|
|
materialized_actor_id: None,
|
|
last_relevant_revision: persisted.revision,
|
|
relevance_lease_until_revision: persisted.revision + 4,
|
|
},
|
|
},
|
|
}];
|
|
let base_binding = format!(
|
|
"campaign:{}:revision:{}:resolution:{}:cell:{}",
|
|
persisted.id, persisted.revision, persisted.resolution_policy.resolution_epoch, cell_id
|
|
);
|
|
let mut verifier = resolution_stage(&cell_id, &persisted, "cell_effect_verifier", '7');
|
|
verifier.snapshot_binding = crate::persona::cell_effect_verification_binding(
|
|
&base_binding,
|
|
std::slice::from_ref(&action),
|
|
)
|
|
.unwrap();
|
|
let mut selector = resolution_stage(
|
|
&cell_id,
|
|
&persisted,
|
|
"strategic_individuation_selector",
|
|
'8',
|
|
);
|
|
selector.rebind_snapshot(crate::scheduler::strategic_individuation_binding(
|
|
&persisted,
|
|
std::slice::from_ref(&action_digest),
|
|
Some(
|
|
&crate::scheduler::strategic_individuation_proposal_digest(
|
|
&wave.strategic_individuations[0],
|
|
)
|
|
.unwrap(),
|
|
),
|
|
));
|
|
for receipt in [verifier, selector] {
|
|
store
|
|
.insert(
|
|
"persona_stage_receipt.v1",
|
|
"ghostlight.persona_stage_receipt.v1",
|
|
receipt.storage_key(),
|
|
&receipt,
|
|
)
|
|
.unwrap();
|
|
wave.model_receipt_hashes
|
|
.push(receipt.storage_key().to_owned());
|
|
}
|
|
let mut substituted = wave.clone();
|
|
substituted.strategic_individuations[0]
|
|
.individuation
|
|
.member
|
|
.name = "Substituted Caller Payload".into();
|
|
let error = kernel
|
|
.command(WorldCommand::AdvanceStrategicTick {
|
|
expected_revision: persisted.revision,
|
|
source: TickSource::Scheduler,
|
|
plan: None,
|
|
model_receipt_hash: Some(format!("sha256:{}", "c".repeat(64))),
|
|
resolution_wave: Some(substituted),
|
|
})
|
|
.await
|
|
.unwrap_err();
|
|
assert!(
|
|
error.to_string().contains("payload-bound selector receipt"),
|
|
"{error}"
|
|
);
|
|
let unchanged = store
|
|
.load::<Campaign>("campaign.v1", &seed.id.to_string())
|
|
.unwrap()
|
|
.unwrap()
|
|
.1;
|
|
assert_eq!(unchanged.revision, persisted.revision);
|
|
assert!(!unchanged.gestalt_members.contains_key("veska-rill"));
|
|
let result = kernel
|
|
.command(WorldCommand::AdvanceStrategicTick {
|
|
expected_revision: persisted.revision,
|
|
source: TickSource::Scheduler,
|
|
plan: None,
|
|
model_receipt_hash: Some(format!("sha256:{}", "b".repeat(64))),
|
|
resolution_wave: Some(wave),
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let CommandResult::Committed { campaign, .. } = result else {
|
|
panic!()
|
|
};
|
|
let member = &campaign.gestalt_members["veska-rill"];
|
|
assert_eq!(
|
|
member.materialized_actor_id.as_deref(),
|
|
Some("member:veska-rill")
|
|
);
|
|
assert_eq!(campaign.actors["member:veska-rill"].name, "Veska Rill");
|
|
assert!(campaign.agency_profiles["member:veska-rill"].simulation_eligible);
|
|
assert!(
|
|
campaign
|
|
.events
|
|
.iter()
|
|
.any(|event| event.kind == "gestalt_individuation")
|
|
);
|
|
let public_individuation = campaign
|
|
.events
|
|
.iter()
|
|
.find(|event| {
|
|
event.kind == "gestalt_individuation"
|
|
&& event
|
|
.public_channels
|
|
.iter()
|
|
.any(|channel| channel == "storm-camp broadsheet")
|
|
})
|
|
.unwrap();
|
|
let public_issue = campaign
|
|
.news
|
|
.iter()
|
|
.find(|issue| issue.event_ids == [public_individuation.id.clone()])
|
|
.unwrap();
|
|
assert_eq!(
|
|
public_individuation.summary,
|
|
"Veska Rill steps forward within Eastern transit refugees to secure the storm route."
|
|
);
|
|
assert!(!public_individuation.summary.contains("selected action"));
|
|
assert_eq!(
|
|
public_issue.headline,
|
|
crate::domain::committed_news_headline(&public_individuation.summary)
|
|
);
|
|
assert!(public_issue.headline.contains("Veska Rill"));
|
|
let proposals = store
|
|
.load_all::<StrategicGestaltIndividuation>("strategic_gestalt_individuation.v1")
|
|
.unwrap();
|
|
assert_eq!(proposals.len(), 1);
|
|
assert_eq!(proposals[0].action_digest, action_digest);
|
|
|
|
let mut second_wave = inaction_wave(&campaign, &store);
|
|
let second_cell_id = second_wave
|
|
.cover
|
|
.cells
|
|
.iter()
|
|
.find(|cell| cell.subject_ids.contains("member:veska-rill"))
|
|
.unwrap()
|
|
.id
|
|
.clone();
|
|
let second_appraisal = second_wave
|
|
.appraisals
|
|
.iter_mut()
|
|
.find(|appraisal| appraisal.cell_id == second_cell_id)
|
|
.unwrap();
|
|
second_appraisal.considered_subject_ids = BTreeSet::from(["member:veska-rill".into()]);
|
|
let second_action = CellActionProposal {
|
|
subject_id: "member:veska-rill".into(),
|
|
intent: "cross the bay to confront the quartermasters".into(),
|
|
intended_effect: "arrive at the south docks without resolving the accusation".into(),
|
|
priority: 91,
|
|
state_references: vec![],
|
|
public_channels: vec![],
|
|
effects: vec![StrategicCellEffect::ActorMove {
|
|
actor_id: "member:veska-rill".into(),
|
|
destination_id: "docks".into(),
|
|
}],
|
|
};
|
|
second_appraisal.actions = vec![second_action.clone()];
|
|
second_appraisal.inactions.clear();
|
|
let second_base_binding = format!(
|
|
"campaign:{}:revision:{}:resolution:{}:cell:{}",
|
|
campaign.id,
|
|
campaign.revision,
|
|
campaign.resolution_policy.resolution_epoch,
|
|
second_cell_id
|
|
);
|
|
let mut second_verifier =
|
|
resolution_stage(&second_cell_id, &campaign, "cell_effect_verifier", 'v');
|
|
second_verifier.snapshot_binding = crate::persona::cell_effect_verification_binding(
|
|
&second_base_binding,
|
|
std::slice::from_ref(&second_action),
|
|
)
|
|
.unwrap();
|
|
store
|
|
.insert(
|
|
"persona_stage_receipt.v1",
|
|
"ghostlight.persona_stage_receipt.v1",
|
|
second_verifier.storage_key(),
|
|
&second_verifier,
|
|
)
|
|
.unwrap();
|
|
second_wave
|
|
.model_receipt_hashes
|
|
.push(second_verifier.storage_key().to_owned());
|
|
let result = kernel
|
|
.command(WorldCommand::AdvanceStrategicTick {
|
|
expected_revision: campaign.revision,
|
|
source: TickSource::Scheduler,
|
|
plan: None,
|
|
model_receipt_hash: Some(test_action_digest("second-veska-wave")),
|
|
resolution_wave: Some(second_wave),
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let CommandResult::Committed {
|
|
campaign: campaign_after_second_wave,
|
|
..
|
|
} = result
|
|
else {
|
|
panic!()
|
|
};
|
|
assert_eq!(
|
|
campaign_after_second_wave.actors["member:veska-rill"].location_id,
|
|
"docks"
|
|
);
|
|
assert!(campaign_after_second_wave.events.iter().any(|event| {
|
|
event.kind == "actor_movement" && event.actor_ids.contains(&"member:veska-rill".into())
|
|
}));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn stale_resolution_wave_leaves_time_clocks_and_campaign_unmutated() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let store = CampaignStore::open(dir.path().join("campaign.cc")).unwrap();
|
|
let kernel = WorldKernel::start(store.clone());
|
|
let seed = crate::resolution::tests::campaign(4, 2);
|
|
kernel
|
|
.command(WorldCommand::CreateCampaign {
|
|
campaign: seed.clone(),
|
|
evidence_receipts: vec![],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let persisted = store
|
|
.load::<Campaign>("campaign.v1", &seed.id.to_string())
|
|
.unwrap()
|
|
.unwrap()
|
|
.1;
|
|
let wave = inaction_wave(&persisted, &store);
|
|
kernel
|
|
.command(WorldCommand::SetResolutionBudget {
|
|
expected_revision: 0,
|
|
expected_resolution_epoch: 0,
|
|
active_cell_budget: 1,
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let before = store
|
|
.load::<Campaign>("campaign.v1", &seed.id.to_string())
|
|
.unwrap()
|
|
.unwrap()
|
|
.1;
|
|
assert!(
|
|
kernel
|
|
.command(WorldCommand::AdvanceStrategicTick {
|
|
expected_revision: 0,
|
|
source: TickSource::Scheduler,
|
|
plan: None,
|
|
model_receipt_hash: Some(format!("sha256:{}", "8".repeat(64))),
|
|
resolution_wave: Some(wave),
|
|
})
|
|
.await
|
|
.is_err()
|
|
);
|
|
let after = store
|
|
.load::<Campaign>("campaign.v1", &seed.id.to_string())
|
|
.unwrap()
|
|
.unwrap()
|
|
.1;
|
|
assert_eq!(after, before);
|
|
assert!(store.keys("strategic_tick.v1").unwrap().is_empty());
|
|
}
|
|
|
|
fn two_player_membership(campaign: &mut Campaign) -> CampaignMembership {
|
|
let mut guest = campaign.actors["player"].clone();
|
|
guest.id = "guest".into();
|
|
guest.name = "Guest".into();
|
|
campaign.actors.insert(guest.id.clone(), guest);
|
|
crate::resolution::ensure_agency_profiles(campaign);
|
|
campaign
|
|
.agency_profiles
|
|
.get_mut("player")
|
|
.unwrap()
|
|
.simulation_eligible = false;
|
|
campaign
|
|
.agency_profiles
|
|
.get_mut("guest")
|
|
.unwrap()
|
|
.simulation_eligible = false;
|
|
CampaignMembership {
|
|
schema: "ghostlight.campaign_membership.v1".into(),
|
|
campaign_id: campaign.id,
|
|
governance_epoch: 0,
|
|
host_member_id: "member:host".into(),
|
|
members: BTreeMap::from([
|
|
(
|
|
"member:host".into(),
|
|
crate::session_zero::CampaignMember {
|
|
member_id: "member:host".into(),
|
|
account_hash: "account:host".into(),
|
|
display_name: "Host".into(),
|
|
actor_id: "player".into(),
|
|
is_host: true,
|
|
active: true,
|
|
cell_allowance: 8,
|
|
},
|
|
),
|
|
(
|
|
"member:guest".into(),
|
|
crate::session_zero::CampaignMember {
|
|
member_id: "member:guest".into(),
|
|
account_hash: "account:guest".into(),
|
|
display_name: "Guest".into(),
|
|
actor_id: "guest".into(),
|
|
is_host: false,
|
|
active: true,
|
|
cell_allowance: 8,
|
|
},
|
|
),
|
|
]),
|
|
extraordinary_permissions: BTreeMap::new(),
|
|
}
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn group_travel_retries_uncommitted_unanimous_approval_and_moves_every_member_once() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let store = CampaignStore::open(dir.path().join("campaign.cc")).unwrap();
|
|
let mut seed = campaign();
|
|
seed.locations.insert(
|
|
"harbor".into(),
|
|
Location {
|
|
id: "harbor".into(),
|
|
name: "Harbor".into(),
|
|
container_id: None,
|
|
routes: BTreeMap::new(),
|
|
persistent_features: vec!["stone quay".into()],
|
|
},
|
|
);
|
|
seed.locations.get_mut("room").unwrap().routes.insert(
|
|
"harbor".into(),
|
|
Route {
|
|
destination_id: "harbor".into(),
|
|
distance: "nearby".into(),
|
|
travel_minutes: 20,
|
|
},
|
|
);
|
|
seed.locations.insert(
|
|
"yard".into(),
|
|
Location {
|
|
id: "yard".into(),
|
|
name: "Yard".into(),
|
|
container_id: None,
|
|
routes: BTreeMap::from([(
|
|
"harbor".into(),
|
|
Route {
|
|
destination_id: "harbor".into(),
|
|
distance: "farther away".into(),
|
|
travel_minutes: 45,
|
|
},
|
|
)]),
|
|
persistent_features: vec!["freight apron".into()],
|
|
},
|
|
);
|
|
let membership = two_player_membership(&mut seed);
|
|
let campaign_id = seed.id;
|
|
let start_time = seed.world_time;
|
|
let kernel = WorldKernel::start(store.clone());
|
|
kernel
|
|
.command(WorldCommand::CreateCampaign {
|
|
campaign: seed,
|
|
evidence_receipts: vec![],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
store
|
|
.insert(
|
|
"campaign_membership.v1",
|
|
"ghostlight.campaign_membership.v1",
|
|
&campaign_id.to_string(),
|
|
&membership,
|
|
)
|
|
.unwrap();
|
|
let pending = kernel
|
|
.command(WorldCommand::ProposeGroupTravel {
|
|
expected_revision: 0,
|
|
member_id: "member:host".into(),
|
|
destination_location_id: "harbor".into(),
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let CommandResult::TravelGovernancePending { proposal, campaign } = pending else {
|
|
panic!("first approval committed a two-member proposal")
|
|
};
|
|
assert_eq!(campaign.revision, 0);
|
|
assert_eq!(campaign.actors["player"].location_id, "room");
|
|
let proposal_id = proposal.id;
|
|
let (proposal_row, mut persisted_proposal) = store
|
|
.load::<GroupTravelProposal>("group_travel_proposal.v1", &proposal_id)
|
|
.unwrap()
|
|
.unwrap();
|
|
persisted_proposal.approvals.insert("member:guest".into());
|
|
store
|
|
.replace(
|
|
&proposal_row,
|
|
"ghostlight.group_travel_proposal.v1",
|
|
&persisted_proposal,
|
|
)
|
|
.unwrap();
|
|
let committed = kernel
|
|
.command(WorldCommand::ApproveGroupTravel {
|
|
expected_revision: 0,
|
|
proposal_id: proposal_id.clone(),
|
|
member_id: "member:host".into(),
|
|
})
|
|
.await
|
|
.unwrap();
|
|
let CommandResult::Committed { campaign, receipt } = committed else {
|
|
panic!("unanimous travel did not commit")
|
|
};
|
|
assert_eq!(receipt.command_kind, "unanimous_group_travel");
|
|
assert_eq!(campaign.revision, 1);
|
|
assert_eq!(campaign.world_time, start_time + Duration::minutes(20));
|
|
assert_eq!(campaign.actors["player"].location_id, "harbor");
|
|
assert_eq!(campaign.actors["guest"].location_id, "harbor");
|
|
let travel_turn = campaign.transcript.last().unwrap();
|
|
assert_eq!(travel_turn.speaker, "world");
|
|
assert!(travel_turn.text.contains("Room"));
|
|
assert!(travel_turn.text.contains("Harbor"));
|
|
assert!(travel_turn.text.contains("20 minutes pass"));
|
|
assert_eq!(
|
|
campaign.agency_profiles["player"].location_ids,
|
|
BTreeSet::from(["harbor".into()])
|
|
);
|
|
assert_eq!(
|
|
campaign.agency_profiles["guest"].location_ids,
|
|
BTreeSet::from(["harbor".into()])
|
|
);
|
|
assert_eq!(
|
|
store.keys("mutation_authority_envelope.v1").unwrap().len(),
|
|
1
|
|
);
|
|
assert_eq!(store.keys("world_mutation_batch.v1").unwrap().len(), 1);
|
|
assert_eq!(store.keys("world_mutation_receipt.v1").unwrap().len(), 1);
|
|
let mut reload_projection = campaign.clone();
|
|
crate::resolution::ensure_agency_profiles(&mut reload_projection);
|
|
assert_eq!(reload_projection, campaign);
|
|
assert!(
|
|
kernel
|
|
.command(WorldCommand::ApproveGroupTravel {
|
|
expected_revision: 0,
|
|
proposal_id,
|
|
member_id: "member:guest".into(),
|
|
})
|
|
.await
|
|
.is_err()
|
|
);
|
|
assert_eq!(
|
|
store
|
|
.load::<Campaign>("campaign.v1", &campaign_id.to_string())
|
|
.unwrap()
|
|
.unwrap()
|
|
.1
|
|
.revision,
|
|
1
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn kernel_rejects_player_effects_against_another_controlled_actor() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let store = CampaignStore::open(dir.path().join("campaign.cc")).unwrap();
|
|
let mut seed = campaign();
|
|
let membership = two_player_membership(&mut seed);
|
|
let kernel = WorldKernel::start(store.clone());
|
|
kernel
|
|
.command(WorldCommand::CreateCampaign {
|
|
campaign: seed.clone(),
|
|
evidence_receipts: vec![],
|
|
model_stage_receipts: vec![],
|
|
})
|
|
.await
|
|
.unwrap();
|
|
store
|
|
.insert(
|
|
"campaign_membership.v1",
|
|
"ghostlight.campaign_membership.v1",
|
|
&seed.id.to_string(),
|
|
&membership,
|
|
)
|
|
.unwrap();
|
|
let intent = ActionIntent {
|
|
actor_id: "player".into(),
|
|
description: "shove Guest".into(),
|
|
intended_effect: "make Guest prone".into(),
|
|
};
|
|
let mut assessment = assess(&seed, intent.clone());
|
|
assessment.success_effect.actor_conditions.insert(
|
|
"guest".into(),
|
|
ConditionDelta {
|
|
add: BTreeSet::from(["prone".into()]),
|
|
remove: BTreeSet::new(),
|
|
},
|
|
);
|
|
assessment.digest = crate::assessor::assessment_digest(&assessment).unwrap();
|
|
let error = kernel
|
|
.command(WorldCommand::Assess {
|
|
expected_revision: 0,
|
|
intent,
|
|
proposal: Some(assessment),
|
|
})
|
|
.await
|
|
.unwrap_err();
|
|
assert!(error.to_string().contains("player-versus-player"));
|
|
let stored = store
|
|
.load::<Campaign>("campaign.v1", &seed.id.to_string())
|
|
.unwrap()
|
|
.unwrap()
|
|
.1;
|
|
assert_eq!(stored.revision, 0);
|
|
assert!(!stored.actors["guest"].conditions.contains("prone"));
|
|
}
|
|
}
|