@zergai/ztc 0.4.0-beta.1 → 0.5.0-beta.1

package/dist/simulation/toolkit/dynamic_game.js

@@ -0,0 +1,805 @@
+import { validateMeetingAdjudications } from './dynamic_meetings.js';
+import { isDeepStrictEqual } from 'node:util';
+import { validFailedAdjudicationCauses } from './dynamic_agents.js';
+import { parseDynamicCharacterProposal, parseDynamicGmProposal, parseDynamicGmConsequences, parseDynamicGmWorldConsequences, } from './dynamic_state.js';
+export class DynamicGameContractError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'DynamicGameContractError';
+    }
+}
+export function validateSimulationInferenceRouting(routing) {
+    const allowed = (routing.serviceTier === undefined || routing.serviceTier === 'priority')
+        && routing.provider === 'codex_legacy'
+        && ((routing.role === 'character' && routing.model === 'gpt-5.6-luna' && routing.reasoningEffort === 'low')
+            || (routing.role === 'game-master' && routing.model === 'gpt-5.6-sol' && routing.reasoningEffort === 'none'));
+    if (!allowed) {
+        throw new DynamicGameContractError('route-not-allowed', 'Character and Game Master requests require approved models and reasoning effort and an omitted or priority service tier');
+    }
+    return structuredClone(routing);
+}
+export function validateCharacterProposal(proposal, context) {
+    assertCharacterProposalShape(proposal, context.agencyVersion === 'emergent-v1', context.interactionVersion === 'meetings-2');
+    if (proposal.attemptedActions.length > 4) {
+        fail('action-count-invalid', 'A character may attempt at most four actions');
+    }
+    proposal = assertCanonicalProposal(() => parseDynamicCharacterProposal(proposal));
+    assertRevision(proposal.basedOnRevision, context.revision);
+    assertId(proposal.proposalId, 'proposalId');
+    assertNewId(proposal.proposalId, context.knownCharacterProposalIds);
+    assertActor(proposal.actorId, context);
+    if (context.interactionVersion === 'meetings-2' && proposal.discussionInvitation !== null) {
+        const invitation = proposal.discussionInvitation;
+        if (!context.knownActorIds.includes(invitation.recipientActorId)
+            || invitation.recipientActorId === proposal.actorId
+            || context.humanControlledActorIds.includes(invitation.recipientActorId)
+            || context.humanControlledActorIds.includes(proposal.actorId)) {
+            fail('discussion-recipient-invalid', 'A discussion invitation must address another known autonomous character');
+        }
+    }
+    if (context.agencyVersion !== 'emergent-v1') {
+        if (proposal.intent === null)
+            fail('intent-required', 'Legacy proposals require an intent');
+        if (proposal.intent.goalId === ''
+            || !context.knownGoalIds[proposal.actorId]?.includes(proposal.intent.goalId)) {
+            fail('unknown-goal', `Character goal ${proposal.intent.goalId} is not active for ${proposal.actorId}`);
+        }
+        assertActorMechanic(proposal.actorId, proposal.intent.mechanic, context);
+        assertText(proposal.intent.summary, 'intent summary', 400);
+        assertTarget(proposal.actorId, proposal.intent.targetActorId, context);
+        assertMechanicTarget(proposal.intent.mechanic, proposal.intent.targetActorId, context);
+        const currentIntent = context.knownCurrentIntents[proposal.actorId] ?? null;
+        if (currentIntent !== null && (proposal.intent.mechanic !== currentIntent.mechanic
+            || proposal.intent.goalId !== currentIntent.goalId
+            || proposal.intent.targetActorId !== currentIntent.targetActorId)) {
+            fail('character-intent-discontinuous', 'A character must continue its committed intent until a causal Game Master update replaces it');
+        }
+    }
+    if (!Array.isArray(proposal.attemptedActions) || proposal.attemptedActions.length > 4) {
+        fail('action-count-invalid', 'A character may attempt at most four actions');
+    }
+    assertUnique(proposal.attemptedActions.map(action => action.id), 'duplicate-action');
+    for (const action of proposal.attemptedActions) {
+        assertNewId(action.id, context.knownActionIds);
+        assertDomainAction(action, context);
+        if (action.actorId !== proposal.actorId) {
+            fail('actor-not-authorized', 'A character may only propose its own actions');
+        }
+        if (context.agencyVersion !== 'emergent-v1')
+            validateActionMotivation(action, proposal, context);
+    }
+    if (context.agencyVersion !== 'emergent-v1' && proposal.intent !== null && proposal.attemptedActions.length > 0 && !proposal.attemptedActions.some(action => (action.mechanic === proposal.intent?.mechanic
+        && action.targetActorId === proposal.intent?.targetActorId))) {
+        fail('character-intent-unlinked', 'A character intent must match at least one attempted action');
+    }
+    assertText(proposal.internalReason, 'internalReason', 800);
+    return structuredClone(proposal);
+}
+export function validateGmProposal(proposal, context) {
+    assertGmProposalShape(proposal, true);
+    return validateGmContents(proposal, context, parseDynamicGmProposal);
+}
+export function validateGmConsequences(proposal, context) {
+    assertGmProposalShape(proposal, false);
+    return validateGmContents(proposal, context, parseDynamicGmConsequences);
+}
+export function validateGmWorldConsequences(proposal, context) {
+    assertGmProposalShape(proposal, false, false);
+    return validateGmContents(proposal, context, parseDynamicGmWorldConsequences);
+}
+function hasAgentUpdates(proposal) {
+    return Object.hasOwn(proposal, 'agentUpdates');
+}
+function validateGmContents(proposal, context, parse) {
+    if (proposal.ending !== null
+        && new Set(proposal.ending.causalEventIds).size !== proposal.ending.causalEventIds.length) {
+        fail('duplicate-ending-cause', 'Ending causes must be unique');
+    }
+    if (proposal.domainActions.length > 16) {
+        fail('action-count-invalid', 'A Game Master may commit at most sixteen actions');
+    }
+    if (!Number.isSafeInteger(proposal.pacing.advanceSteps)
+        || proposal.pacing.advanceSteps < 1
+        || proposal.pacing.advanceSteps > 12) {
+        fail('pacing-invalid', 'Pacing advanceSteps must be an integer from one to twelve');
+    }
+    proposal = assertCanonicalProposal(() => parse(proposal));
+    assertRevision(proposal.basedOnRevision, context.revision);
+    assertId(proposal.proposalId, 'proposalId');
+    assertNewId(proposal.proposalId, context.knownGmProposalIds);
+    assertId(proposal.event.id, 'event.id');
+    assertNewId(proposal.event.id, context.knownHistoryEventIds);
+    assertText(proposal.event.title, 'event title', 160);
+    assertText(proposal.event.narrative, 'event narrative', 2_000);
+    if (!['low', 'medium', 'high', 'critical'].includes(proposal.event.urgency)) {
+        fail('urgency-invalid', 'Event urgency is invalid');
+    }
+    if (!Array.isArray(proposal.event.openQuestions) || proposal.event.openQuestions.length > 6) {
+        fail('question-count-invalid', 'An event may expose at most six questions');
+    }
+    for (const question of proposal.event.openQuestions)
+        assertText(question, 'open question', 240);
+    if ('availableActions' in proposal)
+        validateGmChoices(proposal, context);
+    assertUnique(proposal.domainActions.map(action => action.id), 'duplicate-action');
+    const occupiedActionIds = [
+        ...context.knownActionIds,
+        ...context.characterProposals.flatMap(character => (character.attemptedActions.map(action => action.actionId))),
+    ];
+    for (const action of proposal.domainActions) {
+        assertNewId(action.id, occupiedActionIds);
+        assertDomainAction(action, context);
+        assertGmActionLineage(action, context);
+    }
+    assertUnique(proposal.domainActions
+        .map(action => action.sourceAttemptedActionId)
+        .filter((id) => id !== undefined), 'duplicate-attempt-lineage');
+    assertUnique(proposal.domainActions
+        .map(action => action.sourcePlayerActionId)
+        .filter((id) => id !== undefined), 'duplicate-player-lineage');
+    const actionIds = new Set(proposal.domainActions.map(action => action.id));
+    if (proposal.characterResponses.length > context.knownActorIds.length) {
+        fail('response-count-invalid', 'Character response count exceeds the cast');
+    }
+    assertUnique(proposal.characterResponses.map(response => response.actorId), 'duplicate-character-response');
+    for (const response of proposal.characterResponses) {
+        assertActor(response.actorId, context);
+        if (context.humanControlledActorIds.includes(response.actorId)) {
+            fail('character-response-actor-invalid', 'The Game Master cannot author a response for the human player');
+        }
+        assertText(response.text, 'character response', 600);
+        assertText(response.mood, 'character mood', 80);
+    }
+    const requiredResponseActorIds = new Set([
+        ...context.characterProposals.map(character => character.actorId),
+        ...proposal.domainActions.flatMap(action => (context.actionParticipantActorIds[action.id] ?? [])),
+    ].filter(actorId => !context.humanControlledActorIds.includes(actorId)));
+    const responseActorIds = new Set(proposal.characterResponses.map(response => response.actorId));
+    if (context.agencyVersion !== 'emergent-v1' && [...requiredResponseActorIds].some(actorId => !responseActorIds.has(actorId))) {
+        fail('character-response-missing', 'Every autonomous proposer and affected character needs one visible response');
+    }
+    const expectedProposals = new Set(context.characterProposals.map(item => item.proposalId));
+    validateMeetingAdjudications(proposal, context.meetings ?? [], context.characterProposals.map(character => ({ ...character, attemptedActions: character.attemptedActions })), context.agencyVersion);
+    const adjudicated = proposal.adjudications.map(item => item.characterProposalId);
+    assertUnique(adjudicated, 'duplicate-adjudication');
+    if (adjudicated.length !== expectedProposals.size
+        || adjudicated.some(id => !expectedProposals.has(id))) {
+        fail('unadjudicated-character', 'Every character proposal must be adjudicated exactly once');
+    }
+    for (const adjudication of proposal.adjudications) {
+        assertText(adjudication.reason, 'adjudication reason', 500);
+        if (!['succeeded', 'partial', 'failed', 'deferred'].includes(adjudication.outcome)) {
+            fail('adjudication-outcome-invalid', 'Character adjudication outcome is invalid');
+        }
+        if (adjudication.actionIds.some(id => !actionIds.has(id))) {
+            fail('unlinked-adjudication', 'Adjudications may only cite proposed domain actions');
+        }
+        if (['failed', 'deferred'].includes(adjudication.outcome) && adjudication.actionIds.length > 0) {
+            fail('failed-action-committed', 'A failed character action cannot commit a domain action');
+        }
+        const source = context.characterProposals.find(item => (item.proposalId === adjudication.characterProposalId));
+        if (!source)
+            fail('unadjudicated-character', 'Adjudication source is unknown');
+        if (adjudication.actionIds.some((id) => {
+            const action = proposal.domainActions.find(candidate => candidate.id === id);
+            return action?.sourceCharacterProposalId !== source.proposalId;
+        })) {
+            fail('action-lineage-invalid', 'An adjudication may cite only its own character actions');
+        }
+        if (!['failed', 'deferred'].includes(adjudication.outcome) && adjudication.actionIds.length === 0) {
+            fail('adjudication-inconsistent', 'A successful or partial character ruling must commit a linked action');
+        }
+    }
+    const adjudicatedActions = proposal.adjudications.flatMap(item => item.actionIds);
+    assertUnique(adjudicatedActions, 'duplicate-adjudicated-action');
+    const unadjudicatedNpcAction = proposal.domainActions.find(action => (action.sourceCharacterProposalId !== undefined
+        && !adjudicatedActions.includes(action.id)));
+    if (unadjudicatedNpcAction) {
+        fail('unadjudicated-action', 'Every committed character action needs one adjudication');
+    }
+    const playerAdjudication = proposal.playerAdjudication;
+    const selectedPlayerAction = context.selectedPlayerAction;
+    if ((playerAdjudication === null) !== (selectedPlayerAction === null)) {
+        fail('player-adjudication-invalid', 'Every selected player action needs one Game Master adjudication');
+    }
+    if (playerAdjudication !== null && selectedPlayerAction !== null) {
+        if (playerAdjudication.playerActionId !== selectedPlayerAction.actionId) {
+            fail('player-adjudication-invalid', 'Player adjudication must cite the selected action');
+        }
+        if (!['succeeded', 'partial', 'failed'].includes(playerAdjudication.outcome)) {
+            fail('adjudication-outcome-invalid', 'Player adjudication outcome is invalid');
+        }
+        assertText(playerAdjudication.reason, 'player adjudication reason', 500);
+        assertUnique(playerAdjudication.actionIds, 'duplicate-player-adjudicated-action');
+        if (playerAdjudication.actionIds.some(id => !actionIds.has(id))) {
+            fail('unlinked-player-adjudication', 'Player adjudication may only cite proposed domain actions');
+        }
+        const playerActions = proposal.domainActions.filter(action => (action.sourcePlayerActionId === selectedPlayerAction.actionId));
+        if (playerAdjudication.actionIds.some(id => !playerActions.some(action => action.id === id))
+            || playerActions.some(action => !playerAdjudication.actionIds.includes(action.id))) {
+            fail('player-action-lineage-invalid', 'Player action effects must appear in its adjudication');
+        }
+        if (playerAdjudication.outcome === 'failed' && playerAdjudication.actionIds.length > 0 && selectedPlayerAction.mechanic !== context.freeformMechanic) {
+            fail('failed-action-committed', 'A failed player action cannot commit a domain action');
+        }
+        if (playerAdjudication.outcome !== 'failed' && playerAdjudication.actionIds.length === 0) {
+            fail('adjudication-inconsistent', 'A successful or partial player ruling must commit a linked action');
+        }
+        if (selectedPlayerAction.mechanic === context.freeformMechanic && playerAdjudication.actionIds.length === 0) {
+            fail('free-attempt-unresolved', 'A free player attempt needs recorded consequences, including when its objective fails');
+        }
+    }
+    if (hasAgentUpdates(proposal)) {
+        assertUnique(proposal.agentUpdates.map(update => update.actorId), 'duplicate-agent-update');
+        for (const update of proposal.agentUpdates)
+            validateAgentUpdate(update, proposal, context);
+    }
+    if (!Number.isFinite(proposal.pacing.tension)
+        || proposal.pacing.tension < 0
+        || proposal.pacing.tension > 100) {
+        fail('tension-out-of-bounds', 'Pacing tension must stay between zero and one hundred');
+    }
+    assertText(proposal.pacing.timeAdvance, 'time advance', 100);
+    if (!Number.isSafeInteger(proposal.pacing.advanceSteps)
+        || proposal.pacing.advanceSteps < 1
+        || proposal.pacing.advanceSteps > 12) {
+        fail('pacing-invalid', 'Pacing advance steps must be an integer from one to twelve');
+    }
+    if ((proposal.ending !== null) !== (proposal.pacing.mode === 'resolve')) {
+        fail('resolution-inconsistent', 'Only a resolve proposal may include an ending');
+    }
+    if (proposal.ending) {
+        assertText(proposal.ending.title, 'ending title', 160);
+        assertText(proposal.ending.narrative, 'ending narrative', 2_000);
+        if (!['triumph', 'mixed', 'collapse'].includes(proposal.ending.outcome)) {
+            fail('ending-outcome-invalid', 'Ending outcome is invalid');
+        }
+        assertUnique(proposal.ending.causalEventIds, 'duplicate-ending-cause');
+        if (!proposal.ending.causalEventIds.includes(proposal.event.id)) {
+            fail('ending-current-cause-missing', 'An ending must cite its resolving event');
+        }
+        if (proposal.ending.causalEventIds.length === 0
+            || proposal.ending.causalEventIds.some(id => (id !== proposal.event.id && !context.knownHistoryEventIds.includes(id)))) {
+            fail('ending-cause-invalid', 'An ending must cite known committed or current events');
+        }
+    }
+    return structuredClone(proposal);
+}
+function validateAgentUpdate(update, proposal, context) {
+    const currentEventId = proposal.event.id;
+    assertActor(update.actorId, context);
+    if (update.sourceEventId !== currentEventId) {
+        fail('agent-update-cause-invalid', 'An agent consequence must cite the current event');
+    }
+    assertUnique(update.sourceActionIds, 'duplicate-agent-update-cause');
+    if (!validFailedAdjudicationCauses(update, proposal, context.characterProposals, context.humanControlledActorIds, context.agencyVersion)) {
+        fail('agent-update-cause-invalid', 'An agent consequence must cite at least one committed domain action');
+    }
+    for (const actionId of update.sourceActionIds) {
+        const action = proposal.domainActions.find(candidate => candidate.id === actionId);
+        const participantActorIds = context.actionParticipantActorIds[actionId] ?? [];
+        if (!action || !participantActorIds.includes(update.actorId)) {
+            fail('agent-update-cause-invalid', 'An agent consequence must cite an involved committed action');
+        }
+    }
+    if (update.sourceActionIds.length === 0 && Object.values(update.resourceDeltas).some(delta => delta !== 0)) {
+        fail('agent-update-cause-invalid', 'A failed adjudication cannot change personal resources');
+    }
+    const allGoalIds = context.knownAllGoalIds[update.actorId] ?? [];
+    const activeGoalIds = new Set(context.knownGoalIds[update.actorId] ?? []);
+    assertUnique(update.goalUpdates.map(goal => goal.goalId), 'duplicate-goal-update');
+    for (const goal of update.goalUpdates) {
+        if (!allGoalIds.includes(goal.goalId)) {
+            fail('unknown-goal', `Agent update cites unknown goal ${goal.goalId}`);
+        }
+        if (goal.priority !== undefined && (!Number.isSafeInteger(goal.priority) || goal.priority < 0 || goal.priority > 100)) {
+            fail('priority-out-of-bounds', 'Goal priority must stay between zero and one hundred');
+        }
+        if (context.agencyVersion !== 'emergent-v1' && goal.priority === undefined && goal.status === undefined) {
+            fail('agent-update-noop', 'A goal update must change priority or status');
+        }
+        if (goal.status === 'active')
+            activeGoalIds.add(goal.goalId);
+        else if (goal.status !== undefined)
+            activeGoalIds.delete(goal.goalId);
+    }
+    if (update.goalsToAppend.length > 2 || allGoalIds.length + update.goalsToAppend.length > 16) {
+        fail('goal-count-invalid', 'Agent goals must remain within the shared bound');
+    }
+    assertUnique(update.goalsToAppend.map(goal => goal.id), 'duplicate-goal');
+    for (const goal of update.goalsToAppend) {
+        assertId(goal.id, 'goal id');
+        assertNewId(goal.id, allGoalIds);
+        assertText(goal.description, 'goal description', 500);
+        if (!Number.isSafeInteger(goal.priority) || goal.priority < 0 || goal.priority > 100) {
+            fail('priority-out-of-bounds', 'Goal priority must stay between zero and one hundred');
+        }
+        if (goal.status !== 'active')
+            fail('inactive-new-goal', 'A new goal must start active');
+        if (!['public', 'player-known', 'private'].includes(goal.visibility)) {
+            fail('visibility-invalid', 'Goal visibility is invalid');
+        }
+        activeGoalIds.add(goal.id);
+    }
+    assertUnique(update.beliefUpdates.map(belief => belief.beliefId), 'duplicate-belief-update');
+    for (const belief of update.beliefUpdates) {
+        if (!(context.knownBeliefIds[update.actorId] ?? []).includes(belief.beliefId)) {
+            fail('unknown-belief', `Agent update cites unknown belief ${belief.beliefId}`);
+        }
+        if (!Number.isSafeInteger(belief.confidence) || belief.confidence < 0 || belief.confidence > 100) {
+            fail('confidence-out-of-bounds', 'Belief confidence must stay between zero and one hundred');
+        }
+        assertUnique(belief.evidenceEventIds, 'duplicate-belief-evidence');
+        assertEvidenceEvents(belief.evidenceEventIds, currentEventId, context);
+        if (!belief.evidenceEventIds.includes(currentEventId)) {
+            fail('belief-current-evidence-required', 'A changed belief must cite the event that changed it');
+        }
+    }
+    const knownBeliefIds = context.knownBeliefIds[update.actorId] ?? [];
+    if (update.beliefsToAppend.length > 4 || knownBeliefIds.length + update.beliefsToAppend.length > 32) {
+        fail('belief-count-invalid', 'Agent beliefs must remain within the shared bound');
+    }
+    assertUnique(update.beliefsToAppend.map(belief => belief.id), 'duplicate-belief');
+    for (const belief of update.beliefsToAppend) {
+        assertId(belief.id, 'belief id');
+        assertNewId(belief.id, knownBeliefIds);
+        assertText(belief.subject, 'belief subject', 240);
+        assertText(belief.claim, 'belief claim', 500);
+        if (!Number.isSafeInteger(belief.confidence) || belief.confidence < 0 || belief.confidence > 100) {
+            fail('confidence-out-of-bounds', 'Belief confidence must stay between zero and one hundred');
+        }
+        if (belief.evidenceEventIds.length === 0) {
+            fail('belief-evidence-required', 'A new belief must cite at least one committed or current event');
+        }
+        assertUnique(belief.evidenceEventIds, 'duplicate-belief-evidence');
+        assertEvidenceEvents(belief.evidenceEventIds, currentEventId, context);
+        if (!belief.evidenceEventIds.includes(currentEventId)) {
+            fail('belief-current-evidence-required', 'A new belief must cite the event that created it');
+        }
+        if (!['public', 'player-known', 'private'].includes(belief.visibility)) {
+            fail('visibility-invalid', 'Belief visibility is invalid');
+        }
+    }
+    assertUnique(update.relationshipDeltas.map(item => item.targetActorId), 'duplicate-relationship-update');
+    for (const relationship of update.relationshipDeltas) {
+        assertTarget(update.actorId, relationship.targetActorId, context);
+        const sharesCitedAction = update.sourceActionIds.some(actionId => ((context.actionParticipantActorIds[actionId] ?? []).includes(relationship.targetActorId)));
+        if (context.agencyVersion !== 'emergent-v1' && !sharesCitedAction) {
+            fail('relationship-cause-invalid', 'A relationship consequence must connect participants in one cited action');
+        }
+        for (const value of [relationship.trust, relationship.affinity, relationship.obligation]) {
+            if (!Number.isFinite(value) || value < -100 || value > 100) {
+                fail('relationship-delta-out-of-bounds', 'Relationship deltas must stay between minus and plus one hundred');
+            }
+        }
+        if (context.agencyVersion !== 'emergent-v1' && relationship.trust === 0
+            && relationship.affinity === 0
+            && relationship.obligation === 0) {
+            fail('agent-update-noop', 'A relationship update must change one relationship value');
+        }
+        assertText(relationship.reason, 'relationship reason', 300);
+    }
+    if (update.memoriesToAppend.length > 6)
+        fail('memory-count-invalid', 'At most six memories may be added per agent');
+    assertUnique(update.memoriesToAppend.map(memory => memory.id), 'duplicate-memory');
+    for (const memory of update.memoriesToAppend) {
+        assertId(memory.id, 'memory id');
+        assertNewId(memory.id, context.knownMemoryIds[update.actorId] ?? []);
+        if (memory.eventId !== currentEventId && !context.knownHistoryEventIds.includes(memory.eventId)) {
+            fail('unknown-memory-event', 'Memory must cite a known event');
+        }
+        assertText(memory.summary, 'memory summary', 400);
+        if (!Number.isFinite(memory.salience) || memory.salience < 0 || memory.salience > 100) {
+            fail('salience-out-of-bounds', 'Memory salience must stay between zero and one hundred');
+        }
+    }
+    for (const value of Object.values(update.resourceDeltas)) {
+        if (!Number.isFinite(value) || value < -1_000_000 || value > 1_000_000) {
+            fail('resource-delta-out-of-bounds', 'Resource deltas must be finite and bounded');
+        }
+        if (value === 0) {
+            fail('agent-update-noop', 'An agent resource update must change its resource');
+        }
+    }
+    if (update.nextIntent && context.agencyVersion !== 'emergent-v1') {
+        assertActorMechanic(update.actorId, update.nextIntent.mechanic, context);
+        if (!activeGoalIds.has(update.nextIntent.goalId)) {
+            if (allGoalIds.includes(update.nextIntent.goalId)) {
+                fail('inactive-next-intent', 'Next intent cannot cite an inactive goal');
+            }
+            fail('unknown-goal', 'Next intent must cite an active goal');
+        }
+        assertTarget(update.actorId, update.nextIntent.targetActorId, context);
+        assertMechanicTarget(update.nextIntent.mechanic, update.nextIntent.targetActorId, context);
+    }
+    const currentIntent = context.knownCurrentIntents[update.actorId] ?? null;
+    const autonomous = !context.humanControlledActorIds.includes(update.actorId);
+    if (context.agencyVersion !== 'emergent-v1' && proposal.pacing.mode === 'continue' && autonomous) {
+        if (currentIntent !== null
+            && !activeGoalIds.has(currentIntent.goalId)
+            && update.nextIntent === null) {
+            fail('intent-successor-required', 'A resolved current intent needs one causal successor while the run continues');
+        }
+        if (activeGoalIds.size === 0) {
+            fail('autonomous-agent-retired', 'A continuing run cannot retire an autonomous character without an active successor goal');
+        }
+    }
+}
+function assertEvidenceEvents(eventIds, currentEventId, context) {
+    if (eventIds.some(id => !context.knownHistoryEventIds.includes(id) && id !== currentEventId)) {
+        fail('unknown-memory-event', 'Belief evidence must cite a known event');
+    }
+}
+function assertCharacterProposalShape(proposal, emergent, invitations) {
+    const value = assertExactObject(proposal, ['schemaVersion', 'proposalId', 'basedOnRevision', 'actorId', 'intent', 'attemptedActions', 'internalReason', ...(invitations ? ['discussionInvitation'] : [])], [], 'character proposal');
+    if (value.schemaVersion !== 1)
+        fail('proposal-shape-invalid', 'Character proposal schema version must be one');
+    if (!emergent || value.intent !== null)
+        assertIntentShape(value.intent, 'character intent');
+    for (const action of assertArray(value.attemptedActions, 'character attemptedActions')) {
+        assertCharacterActionShape(action, emergent);
+    }
+}
+function assertCharacterActionShape(action, emergent) {
+    const value = assertExactObject(action, [
+        'id', 'mechanic', 'actorId', 'targetActorId', 'parameters', 'reason', 'motivation',
+    ], ['targetActorId'], 'character attempted action');
+    assertJsonObject(value.parameters, 'character attempted action parameters');
+    if (!emergent || value.motivation !== null)
+        assertExactObject(value.motivation, ['goalId', 'beliefId', 'memoryId', 'relationshipTargetActorId', 'resourceId'], [], 'character action motivation');
+}
+function validateGmChoices(proposal, context) {
+    const resolving = proposal.pacing.mode === 'resolve';
+    if (!Array.isArray(proposal.availableActions)
+        || (!resolving && (proposal.availableActions.length < (context.allowScarcePlayerChoices ? 0 : 2) || proposal.availableActions.length > 4))
+        || (resolving && proposal.availableActions.length !== 0)) {
+        fail('available-action-count-invalid', 'Active proposals need two to four actions; resolved proposals need none');
+    }
+    assertUnique(proposal.availableActions.map(action => action.id), 'duplicate-available-action');
+    for (let leftIndex = 0; leftIndex < proposal.availableActions.length; leftIndex += 1) {
+        const left = proposal.availableActions[leftIndex];
+        if (!left)
+            continue;
+        for (let rightIndex = leftIndex + 1; rightIndex < proposal.availableActions.length; rightIndex += 1) {
+            const right = proposal.availableActions[rightIndex];
+            if (!right)
+                continue;
+            if (left.mechanic === right.mechanic
+                && left.targetActorId === right.targetActorId
+                && isDeepStrictEqual(left.parameters, right.parameters)) {
+                fail('duplicate-available-action-semantics', 'Available actions must differ in mechanic, target, or parameters');
+            }
+        }
+    }
+    for (const action of proposal.availableActions) {
+        assertId(action.id, 'available action id');
+        assertPlayerMechanic(action.mechanic, context);
+        assertTarget(context.humanControlledActorIds[0], action.targetActorId, context);
+        assertText(action.label, 'action label', 120);
+        assertText(action.intent, 'action intent', 240);
+        assertText(action.description, 'action description', 500);
+        if (!['game-master', 'fallback'].includes(action.authoredBy)) {
+            fail('action-author-invalid', 'Available action author is invalid');
+        }
+        if (action.risks.length > 6 || action.requirements.length > 6) {
+            fail('action-detail-count-invalid', 'Action risks and requirements are bounded to six each');
+        }
+        for (const risk of action.risks)
+            assertText(risk, 'action risk', 300);
+        for (const requirement of action.requirements)
+            assertText(requirement, 'action requirement', 300);
+        assertBoundedParameters(action.parameters);
+    }
+}
+function assertGmProposalShape(proposal, choices, updates = true) {
+    const value = assertExactObject(proposal, [
+        'schemaVersion', 'proposalId', 'basedOnRevision', 'event', ...(choices ? ['availableActions'] : []),
+        'characterResponses', 'adjudications', 'playerAdjudication', 'domainActions',
+        ...(updates ? ['agentUpdates'] : []), 'pacing', 'ending',
+    ], [], 'Game Master proposal');
+    if (value.schemaVersion !== 1)
+        fail('proposal-shape-invalid', 'Game Master proposal schema version must be one');
+    assertExactObject(value.event, ['id', 'title', 'narrative', 'urgency', 'openQuestions'], [], 'event');
+    for (const action of choices ? assertArray(value.availableActions, 'availableActions') : []) {
+        const item = assertExactObject(action, ['id', 'label', 'intent', 'description', 'mechanic', 'targetActorId', 'parameters', 'risks', 'requirements', 'authoredBy'], ['targetActorId'], 'available action');
+        assertJsonObject(item.parameters, 'available action parameters');
+        assertArray(item.risks, 'available action risks');
+        assertArray(item.requirements, 'available action requirements');
+    }
+    for (const response of assertArray(value.characterResponses, 'characterResponses')) {
+        assertExactObject(response, ['actorId', 'text', 'mood'], [], 'character response');
+    }
+    for (const adjudication of assertArray(value.adjudications, 'adjudications')) {
+        const item = assertExactObject(adjudication, ['characterProposalId', 'outcome', 'reason', 'actionIds', 'meetingId'], ['meetingId'], 'character adjudication');
+        assertArray(item.actionIds, 'adjudication actionIds');
+    }
+    if (value.playerAdjudication !== null) {
+        const adjudication = assertExactObject(value.playerAdjudication, ['playerActionId', 'outcome', 'reason', 'actionIds'], [], 'player adjudication');
+        assertArray(adjudication.actionIds, 'player adjudication actionIds');
+    }
+    for (const action of assertArray(value.domainActions, 'domainActions')) {
+        assertDomainActionShape(action, 'Game Master domain action');
+    }
+    if (updates) {
+        for (const update of assertArray(value.agentUpdates, 'agentUpdates'))
+            assertAgentUpdateShape(update);
+    }
+    assertExactObject(value.pacing, ['mode', 'tension', 'timeAdvance', 'advanceSteps'], [], 'pacing');
+    if (value.ending !== null) {
+        const ending = assertExactObject(value.ending, ['title', 'narrative', 'outcome', 'causalEventIds', 'endingBasis'], ['endingBasis'], 'ending');
+        assertArray(ending.causalEventIds, 'ending causalEventIds');
+    }
+}
+function assertAgentUpdateShape(update) {
+    const value = assertExactObject(update, [
+        'actorId', 'sourceEventId', 'sourceActionIds', 'sourceAdjudicationProposalIds', 'goalUpdates', 'goalsToAppend', 'beliefUpdates', 'beliefsToAppend', 'relationshipDeltas',
+        'memoriesToAppend', 'resourceDeltas', 'nextIntent',
+    ], ['sourceAdjudicationProposalIds'], 'agent update');
+    assertArray(value.sourceActionIds, 'agent update sourceActionIds');
+    if (value.sourceAdjudicationProposalIds !== undefined)
+        assertArray(value.sourceAdjudicationProposalIds, 'agent update sourceAdjudicationProposalIds');
+    for (const goal of assertArray(value.goalUpdates, 'goalUpdates')) {
+        assertExactObject(goal, ['goalId', 'priority', 'status'], ['priority', 'status'], 'goal update');
+    }
+    for (const goal of assertArray(value.goalsToAppend, 'goalsToAppend')) {
+        assertExactObject(goal, ['id', 'description', 'priority', 'status', 'visibility'], [], 'new goal');
+    }
+    for (const belief of assertArray(value.beliefUpdates, 'beliefUpdates')) {
+        const item = assertExactObject(belief, ['beliefId', 'confidence', 'evidenceEventIds'], [], 'belief update');
+        assertArray(item.evidenceEventIds, 'belief evidenceEventIds');
+    }
+    for (const belief of assertArray(value.beliefsToAppend, 'beliefsToAppend')) {
+        const item = assertExactObject(belief, ['id', 'subject', 'claim', 'confidence', 'evidenceEventIds', 'visibility'], [], 'new belief');
+        assertArray(item.evidenceEventIds, 'new belief evidenceEventIds');
+    }
+    for (const relationship of assertArray(value.relationshipDeltas, 'relationshipDeltas')) {
+        assertExactObject(relationship, ['targetActorId', 'trust', 'affinity', 'obligation', 'reason'], [], 'relationship delta');
+    }
+    for (const memory of assertArray(value.memoriesToAppend, 'memoriesToAppend')) {
+        assertExactObject(memory, ['id', 'eventId', 'kind', 'summary', 'salience', 'visibility'], [], 'memory');
+    }
+    assertJsonObject(value.resourceDeltas, 'agent resourceDeltas');
+    if (value.nextIntent !== null)
+        assertIntentShape(value.nextIntent, 'next intent');
+}
+function assertIntentShape(intent, label) {
+    assertExactObject(intent, ['mechanic', 'goalId', 'summary', 'targetActorId'], ['targetActorId'], label);
+}
+function assertDomainActionShape(action, label) {
+    const value = assertExactObject(action, [
+        'id', 'mechanic', 'actorId', 'targetActorId', 'sourceCharacterProposalId',
+        'sourceAttemptedActionId', 'sourcePlayerActionId', 'parameters', 'reason',
+    ], [
+        'actorId', 'targetActorId', 'sourceCharacterProposalId',
+        'sourceAttemptedActionId', 'sourcePlayerActionId',
+    ], label);
+    assertJsonObject(value.parameters, `${label} parameters`);
+}
+function assertExactObject(value, allowedKeys, optionalKeys, label) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        fail('proposal-shape-invalid', `${label} must be an object`);
+    }
+    const record = value;
+    const actualKeys = Object.keys(record);
+    if (actualKeys.some(key => !allowedKeys.includes(key))) {
+        fail('proposal-shape-invalid', `${label} contains an unknown field`);
+    }
+    if (allowedKeys.some(key => !optionalKeys.includes(key)
+        && !Object.prototype.hasOwnProperty.call(record, key))) {
+        fail('proposal-shape-invalid', `${label} is missing a required field`);
+    }
+    return record;
+}
+function assertJsonObject(value, label) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        fail('proposal-shape-invalid', `${label} must be an object`);
+    }
+}
+function assertArray(value, label) {
+    if (!Array.isArray(value))
+        fail('proposal-shape-invalid', `${label} must be an array`);
+    return value;
+}
+function assertDomainAction(action, context) {
+    assertId(action.id, 'domain action id');
+    if (action.actorId === undefined)
+        assertMechanic(action.mechanic, context);
+    else
+        assertActorMechanic(action.actorId, action.mechanic, context);
+    if (action.actorId !== undefined)
+        assertActor(action.actorId, context);
+    assertTarget(action.actorId, action.targetActorId, context);
+    assertText(action.reason, 'domain action reason', 500);
+    assertBoundedParameters(action.parameters);
+}
+function validateActionMotivation(action, proposal, context) {
+    const motivation = action.motivation;
+    if (motivation === null || proposal.intent === null)
+        fail('motivation-required', 'Legacy actions require an intent and motivation');
+    if (motivation.goalId !== proposal.intent.goalId) {
+        fail('action-motivation-goal-invalid', 'An autonomous action must cite its active intent goal');
+    }
+    if (!(context.knownBeliefIds[proposal.actorId] ?? []).includes(motivation.beliefId)) {
+        fail('action-motivation-belief-invalid', 'An autonomous action must cite one belief owned by its actor');
+    }
+    if (!(context.knownMemoryIds[proposal.actorId] ?? []).includes(motivation.memoryId)) {
+        fail('action-motivation-memory-invalid', 'An autonomous action must cite one memory owned by its actor');
+    }
+    if (!(context.knownRelationshipActorIds[proposal.actorId] ?? []).includes(motivation.relationshipTargetActorId) || (action.targetActorId !== undefined
+        && motivation.relationshipTargetActorId !== action.targetActorId)) {
+        fail('action-motivation-relationship-invalid', 'An autonomous action must cite its involved persistent relationship');
+    }
+    if (!(context.knownResourceIds[proposal.actorId] ?? []).includes(motivation.resourceId)) {
+        fail('action-motivation-resource-invalid', 'An autonomous action must cite one resource owned by its actor');
+    }
+}
+function assertGmActionLineage(action, context) {
+    if (action.actorId === undefined) {
+        if (action.sourceCharacterProposalId !== undefined
+            || action.sourceAttemptedActionId !== undefined
+            || action.sourcePlayerActionId !== undefined) {
+            fail('action-lineage-invalid', 'A world action cannot claim an actor action source');
+        }
+        return;
+    }
+    if (context.humanControlledActorIds.includes(action.actorId)) {
+        const selected = context.selectedPlayerAction;
+        if (selected === null
+            || selected.actorId !== action.actorId
+            || selected.mechanic !== action.mechanic
+            || selected.targetActorId !== action.targetActorId
+            || selected.actionId !== action.sourcePlayerActionId
+            || action.sourceCharacterProposalId !== undefined
+            || action.sourceAttemptedActionId !== undefined) {
+            fail('human-action-not-selected', 'A human actor action must match the selected player action');
+        }
+        assertIntentPreserved(selected.parameters, action.parameters);
+        return;
+    }
+    if (action.sourcePlayerActionId !== undefined) {
+        fail('action-lineage-invalid', 'An autonomous actor cannot claim a player action source');
+    }
+    const proposal = context.characterProposals.find(item => (item.proposalId === action.sourceCharacterProposalId));
+    const attempted = proposal?.attemptedActions.find(item => (item.actionId === action.sourceAttemptedActionId));
+    if (!proposal
+        || proposal.actorId !== action.actorId
+        || !attempted
+        || attempted.mechanic !== action.mechanic
+        || attempted.targetActorId !== action.targetActorId) {
+        fail('action-lineage-invalid', 'A character action must match its proposed actor, mechanic, and target');
+    }
+    assertIntentPreserved(attempted.parameters, action.parameters);
+}
+function assertIntentPreserved(sourceParameters, committedParameters) {
+    const sourceIntent = Object.prototype.hasOwnProperty.call(sourceParameters, 'intent')
+        ? sourceParameters.intent
+        : sourceParameters;
+    const committedIntent = Object.prototype.hasOwnProperty.call(committedParameters, 'intent')
+        ? committedParameters.intent
+        : committedParameters;
+    if (!isDeepStrictEqual(sourceIntent, committedIntent)) {
+        fail('action-intent-changed', 'The Game Master cannot replace a source action intent');
+    }
+}
+function assertRevision(actual, expected) {
+    if (!Number.isSafeInteger(actual) || actual !== expected) {
+        fail('stale-revision', `Proposal revision ${actual} does not match ${expected}`);
+    }
+}
+function assertMechanic(mechanic, context) {
+    if (!context.allowedMechanics.includes(mechanic)) {
+        fail('mechanic-not-allowed', `Mechanic ${mechanic} is not allowed`);
+    }
+}
+function assertActorMechanic(actorId, mechanic, context) {
+    assertMechanic(mechanic, context);
+    if (!context.actorMechanics[actorId]?.includes(mechanic)) {
+        fail('actor-mechanic-not-allowed', `Actor ${actorId} cannot use mechanic ${mechanic}`);
+    }
+}
+function assertMechanicTarget(mechanic, targetActorId, context) {
+    const target = context.mechanicTargets[mechanic];
+    if (target === undefined) {
+        fail('mechanic-not-allowed', `Mechanic ${mechanic} has no target contract`);
+    }
+    if (target === 'required' && targetActorId === undefined) {
+        fail('mechanic-target-invalid', `Mechanic ${mechanic} needs a target actor`);
+    }
+    if (target === 'none' && targetActorId !== undefined) {
+        fail('mechanic-target-invalid', `Mechanic ${mechanic} cannot target an actor`);
+    }
+}
+function assertPlayerMechanic(mechanic, context) {
+    assertMechanic(mechanic, context);
+    if (!context.humanControlledActorIds.some(actorId => (context.actorMechanics[actorId]?.includes(mechanic)))) {
+        fail('player-mechanic-not-allowed', `Players cannot use mechanic ${mechanic}`);
+    }
+}
+function assertActor(actorId, context) {
+    if (!context.knownActorIds.includes(actorId))
+        fail('unknown-actor', `Actor ${actorId} is unknown`);
+}
+function assertTarget(actorId, targetActorId, context) {
+    if (targetActorId === undefined)
+        return;
+    assertActor(targetActorId, context);
+    if (actorId === targetActorId)
+        fail('self-target-invalid', 'An actor cannot target itself');
+}
+function assertId(value, label) {
+    if (typeof value !== 'string' || value.trim() === '' || value.length > 128) {
+        fail('id-invalid', `${label} must be a non-empty identifier of at most 128 characters`);
+    }
+}
+function assertText(value, label, maximum) {
+    if (typeof value !== 'string' || value.trim() === '' || value.length > maximum) {
+        fail('text-invalid', `${label} must contain bounded text`);
+    }
+}
+function assertUnique(values, code) {
+    if (new Set(values).size !== values.length)
+        fail(code, 'Identifiers must be unique');
+}
+function assertNewId(value, known) {
+    if (known.includes(value))
+        fail('identifier-reused', `Identifier ${value} was already committed`);
+}
+function assertCanonicalProposal(parse) {
+    try {
+        return parse();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Dynamic proposal shape is invalid';
+        fail('proposal-shape-invalid', message);
+    }
+}
+function assertBoundedParameters(value) {
+    let serialized;
+    try {
+        serialized = JSON.stringify(value);
+    }
+    catch {
+        fail('parameters-out-of-bounds', 'Action parameters must be valid bounded JSON');
+    }
+    if (new TextEncoder().encode(serialized).byteLength > 2_048) {
+        fail('parameters-out-of-bounds', 'Action parameters exceed 2,048 bytes');
+    }
+    visitJson(value, 0, { keys: 0 });
+}
+function visitJson(value, depth, budget) {
+    if (depth > 4)
+        fail('parameters-out-of-bounds', 'Action parameters exceed four levels');
+    if (value === null || typeof value === 'boolean')
+        return;
+    if (typeof value === 'string') {
+        if (value.length > 1_000)
+            fail('parameters-out-of-bounds', 'Action parameter text is too long');
+        return;
+    }
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value))
+            fail('parameters-out-of-bounds', 'Action parameter numbers must be finite');
+        return;
+    }
+    if (Array.isArray(value)) {
+        if (value.length > 32)
+            fail('parameters-out-of-bounds', 'Action parameter arrays are limited to 32 items');
+        for (const item of value)
+            visitJson(item, depth + 1, budget);
+        return;
+    }
+    if (typeof value !== 'object') {
+        fail('parameters-out-of-bounds', 'Action parameters must contain JSON values');
+    }
+    const entries = Object.entries(value);
+    budget.keys += entries.length;
+    if (budget.keys > 32)
+        fail('parameters-out-of-bounds', 'Action parameters are limited to 32 keys');
+    for (const [, item] of entries)
+        visitJson(item, depth + 1, budget);
+}
+function fail(code, message) {
+    throw new DynamicGameContractError(code, message);
+}