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

package/dist/plugin/simulation_contract.d.ts

@@ -1,3 +1,9 @@
+import type { CodexReasoningEffort } from '../config/types.js';
+import type { StoryEpisodeV1, StoryReviewReceiptV1, StoryReviewViewV1 } from './simulation_story_review.js';
+import type { BufferedRecoveryPolicy, BufferedTransportAttempt } from '../agent/backends/types.js';
+import type { SimulationDocumentProvenanceV1 } from './simulation_documents.js';
+import type { SimulationInteractionStateV1, SimulationMeetingV1, SimulationMeetingActivityV1 } from './simulation_meetings.js';
+import type { DynamicInitialization, DynamicInitializationV1, StorytellerReceiptV1 } from './simulation_storyteller.js';
 /**
  * Versioned contract between ZTC and simulation product plugins.
  *
@@ -48,11 +54,13 @@ export interface SimulationCreateSessionRequestV1 {
     };
     readonly runtime: SimulationRuntimeOptionsV1;
     readonly actors?: readonly SimulationActorSeedV1[];
+    readonly dynamicState?: SimulationDynamicStateV1;
     readonly pluginData?: SimulationJsonObjectV1;
 }
 export interface SimulationLoadSessionRequestV1 {
     readonly checkpointPath: string;
     readonly driverKind?: string;
+    readonly outputDirectory?: string;
 }
 export interface SimulationSessionRefV1 {
     readonly sessionId: string;
@@ -78,6 +86,8 @@ export interface SimulationDocumentCommentSnapshotV1 {
     readonly sectionRef?: string;
 }
 export interface SimulationDocumentSnapshotV1 {
+    readonly provenance?: SimulationDocumentProvenanceV1;
+    readonly ownerActorId?: string;
     readonly documentId: string;
     readonly label: string;
     readonly type: string;
@@ -91,6 +101,7 @@ export interface SimulationDocumentSnapshotV1 {
     readonly metadata?: SimulationJsonObjectV1;
 }
 export interface SimulationSessionSnapshotV1 {
+    readonly inputJournal?: import('./simulation_interventions.js').SimulationInputJournalV1;
     readonly ref: SimulationSessionRefV1;
     readonly status: SimulationSessionStatusV1;
     readonly revision: number;
@@ -99,6 +110,7 @@ export interface SimulationSessionSnapshotV1 {
     readonly actors: readonly SimulationActorSnapshotV1[];
     readonly documents: readonly SimulationDocumentSnapshotV1[];
     readonly world: SimulationJsonObjectV1 | null;
+    readonly dynamicState?: SimulationDynamicStateV1 | null;
     readonly pluginData: SimulationJsonObjectV1;
 }
 export interface SimulationCheckpointExtensionV1 {
@@ -131,16 +143,801 @@ export interface SimulationInferenceContextV1 {
     readonly component?: string;
     readonly attempt?: number;
 }
+export interface SimulationInferenceRoutingV1 {
+    readonly provider: string;
+    readonly role: 'character' | 'game-master';
+    readonly model: string;
+    readonly reasoningEffort: CodexReasoningEffort;
+    readonly serviceTier?: 'priority';
+}
 export interface SimulationInferenceRequestV1 {
+    readonly bufferedRecovery?: BufferedRecoveryPolicy;
+    /** Lifecycle observer; excluded from the original serialized request. */
+    readonly onTransportAttempt?: (event: BufferedTransportAttempt) => void;
     readonly system: string;
     readonly user: string;
     readonly maxTokens?: number;
     readonly timeoutMs?: number;
+    readonly outputSchema?: Record<string, unknown>;
+    readonly outputSchemaStrict?: boolean;
+    readonly routing?: SimulationInferenceRoutingV1;
     readonly context: SimulationInferenceContextV1;
 }
 export interface SimulationInferenceResultV1 {
     readonly text: string;
 }
+export type SimulationKnowledgeVisibilityV1 = 'public' | 'player-known' | 'private';
+export interface SimulationAgentGoalV1 {
+    readonly id: string;
+    readonly description: string;
+    readonly priority: number;
+    readonly status: 'active' | 'satisfied' | 'blocked' | 'abandoned';
+    readonly visibility: SimulationKnowledgeVisibilityV1;
+}
+export interface SimulationAgentBeliefV1 {
+    readonly id: string;
+    readonly subject: string;
+    readonly claim: string;
+    readonly confidence: number;
+    readonly evidenceEventIds: readonly string[];
+    readonly visibility: SimulationKnowledgeVisibilityV1;
+}
+export interface SimulationAgentRelationshipV1 {
+    readonly targetActorId: string;
+    readonly trust: number;
+    readonly affinity: number;
+    readonly obligation: number;
+    readonly conflictNotes: readonly string[];
+    readonly changedByEventId?: string;
+    readonly visibility: SimulationKnowledgeVisibilityV1;
+}
+export interface SimulationAgentMemoryV1 {
+    readonly id: string;
+    readonly eventId: string;
+    readonly kind: 'observation' | 'promise' | 'conflict' | 'cooperation' | 'outcome';
+    readonly summary: string;
+    readonly salience: number;
+    readonly visibility: SimulationKnowledgeVisibilityV1;
+}
+export interface SimulationAgentIntentV1 {
+    readonly mechanic: string;
+    readonly goalId: string;
+    readonly summary: string;
+    readonly targetActorId?: string;
+}
+export interface SimulationPersistentAgentStateV1 {
+    readonly actorId: string;
+    readonly name: string;
+    readonly role: string;
+    readonly humanControlled: boolean;
+    readonly capabilities: readonly string[];
+    readonly goals: readonly SimulationAgentGoalV1[];
+    readonly beliefs: readonly SimulationAgentBeliefV1[];
+    readonly relationships: readonly SimulationAgentRelationshipV1[];
+    readonly memories: readonly SimulationAgentMemoryV1[];
+    readonly resources: Readonly<Record<string, number>>;
+    readonly resourceVisibility: Readonly<Record<string, SimulationKnowledgeVisibilityV1>>;
+    readonly currentIntent: SimulationAgentIntentV1 | null;
+}
+export interface SimulationDomainActionProposalV1 {
+    readonly id: string;
+    readonly mechanic: string;
+    readonly actorId?: string;
+    readonly targetActorId?: string;
+    readonly sourceCharacterProposalId?: string;
+    readonly sourceAttemptedActionId?: string;
+    readonly sourcePlayerActionId?: string;
+    readonly parameters: SimulationJsonObjectV1;
+    readonly reason: string;
+}
+export interface SimulationCharacterActionMotivationV1 {
+    readonly goalId: string;
+    readonly beliefId: string;
+    readonly memoryId: string;
+    readonly relationshipTargetActorId: string;
+    readonly resourceId: string;
+}
+export type SimulationCharacterActionProposalV1 = Omit<SimulationDomainActionProposalV1, 'actorId' | 'sourceCharacterProposalId' | 'sourceAttemptedActionId' | 'sourcePlayerActionId'> & {
+    readonly actorId: string;
+    readonly motivation: SimulationCharacterActionMotivationV1 | null;
+};
+/** A validated intention. It does not assert that an action occurred. */
+export interface SimulationDynamicIntentActivityV1 {
+    readonly kind: 'actor-intent';
+    readonly status: 'pending';
+    readonly validation: 'ztc-character-proposal';
+    readonly basedOnRevision: number;
+    readonly sourceProposalId: string;
+    readonly actorId: string;
+    readonly actorName: string;
+    readonly mechanic: string;
+    readonly text: string;
+}
+export type SimulationDynamicActivityV1 = SimulationDynamicIntentActivityV1 | SimulationMeetingActivityV1;
+export interface SimulationDiscussionInvitationV1 {
+    readonly recipientActorId: string;
+    readonly topic: string;
+}
+export interface SimulationCharacterProposalV1 {
+    readonly schemaVersion: 1;
+    readonly proposalId: string;
+    readonly basedOnRevision: number;
+    readonly actorId: string;
+    readonly intent: SimulationAgentIntentV1 | null;
+    readonly discussionInvitation?: SimulationDiscussionInvitationV1 | null;
+    readonly attemptedActions: readonly SimulationCharacterActionProposalV1[];
+    readonly internalReason: string;
+}
+export interface SimulationDynamicPlayerActionV1 {
+    readonly id: string;
+    readonly label: string;
+    readonly intent: string;
+    readonly description: string;
+    readonly mechanic: string;
+    readonly targetActorId?: string;
+    readonly parameters: SimulationJsonObjectV1;
+    readonly risks: readonly string[];
+    readonly requirements: readonly string[];
+    readonly authoredBy: 'game-master' | 'fallback' | 'player';
+}
+export interface SimulationAgentUpdateProposalV1 {
+    readonly actorId: string;
+    readonly sourceEventId: string;
+    readonly sourceActionIds: readonly string[];
+    readonly sourceAdjudicationProposalIds?: readonly string[];
+    readonly goalUpdates: readonly {
+        readonly goalId: string;
+        readonly priority?: number;
+        readonly status?: SimulationAgentGoalV1['status'];
+    }[];
+    readonly goalsToAppend: readonly SimulationAgentGoalV1[];
+    readonly beliefUpdates: readonly {
+        readonly beliefId: string;
+        readonly confidence: number;
+        readonly evidenceEventIds: readonly string[];
+    }[];
+    readonly beliefsToAppend: readonly SimulationAgentBeliefV1[];
+    readonly relationshipDeltas: readonly {
+        readonly targetActorId: string;
+        readonly trust: number;
+        readonly affinity: number;
+        readonly obligation: number;
+        readonly reason: string;
+    }[];
+    readonly memoriesToAppend: readonly SimulationAgentMemoryV1[];
+    readonly resourceDeltas: Readonly<Record<string, number>>;
+    readonly nextIntent: SimulationAgentIntentV1 | null;
+}
+/** Private validated consequences before the Game Master authors next choices. */
+export type SimulationGmConsequencesV1 = Omit<SimulationGmProposalV1, 'availableActions'>;
+/** Private world adjudication before affected actors receive authored consequences. */
+export type SimulationGmWorldConsequencesV1 = Omit<SimulationGmConsequencesV1, 'agentUpdates'>;
+export interface SimulationGmProposalV1 {
+    readonly schemaVersion: 1;
+    readonly proposalId: string;
+    readonly basedOnRevision: number;
+    readonly event: {
+        readonly id: string;
+        readonly title: string;
+        readonly narrative: string;
+        readonly urgency: 'low' | 'medium' | 'high' | 'critical';
+        readonly openQuestions: readonly string[];
+    };
+    readonly availableActions: readonly SimulationDynamicPlayerActionV1[];
+    readonly characterResponses: readonly {
+        readonly actorId: string;
+        readonly text: string;
+        readonly mood: string;
+    }[];
+    readonly adjudications: readonly {
+        readonly characterProposalId: string;
+        readonly outcome: 'succeeded' | 'partial' | 'failed' | 'deferred';
+        readonly meetingId?: string;
+        readonly reason: string;
+        readonly actionIds: readonly string[];
+    }[];
+    readonly playerAdjudication: null | {
+        readonly playerActionId: string;
+        readonly outcome: 'succeeded' | 'partial' | 'failed';
+        readonly reason: string;
+        readonly actionIds: readonly string[];
+    };
+    readonly domainActions: readonly SimulationDomainActionProposalV1[];
+    readonly agentUpdates: readonly SimulationAgentUpdateProposalV1[];
+    readonly pacing: {
+        readonly mode: 'continue' | 'resolve';
+        readonly tension: number;
+        readonly timeAdvance: string;
+        readonly advanceSteps: number;
+    };
+    readonly ending: null | {
+        readonly title: string;
+        readonly narrative: string;
+        readonly outcome: 'triumph' | 'mixed' | 'collapse';
+        readonly causalEventIds: readonly string[];
+        readonly endingBasis?: {
+            readonly predicateId: string;
+            readonly witnesses: readonly {
+                readonly objectId: string;
+                readonly version: number;
+                readonly actionId: string;
+                readonly eventId: string;
+            }[];
+            readonly actorIds: readonly string[];
+        };
+    };
+}
+export type SimulationDynamicRunStatusV1 = 'active' | 'ended' | 'safety-stopped';
+export interface SimulationDynamicResourceDefinitionV1 {
+    readonly id: string;
+    readonly label: string;
+    readonly minimum: number;
+    readonly maximum: number;
+    readonly initial: number;
+    readonly maximumStep: number;
+    readonly dangerDirection: 'low' | 'high' | 'none';
+    readonly visibility?: SimulationKnowledgeVisibilityV1;
+}
+interface SimulationDynamicParameterDefinitionBaseV1 {
+    readonly id: string;
+    readonly label: string;
+    readonly required?: boolean;
+    /** Bind a scalar to one selected visible object's current field. */
+    readonly valueFrom?: {
+        readonly objectParameter: string;
+        readonly path: readonly string[];
+    };
+}
+export type SimulationDynamicParameterDefinitionV1 = (SimulationDynamicParameterDefinitionBaseV1 & {
+    readonly kind: 'text';
+    readonly minimumLength?: number;
+    readonly maximumLength: number;
+}) | (SimulationDynamicParameterDefinitionBaseV1 & {
+    readonly kind: 'number' | 'integer';
+    readonly minimum: number;
+    readonly maximum: number;
+}) | (SimulationDynamicParameterDefinitionBaseV1 & {
+    readonly kind: 'boolean';
+}) | (SimulationDynamicParameterDefinitionBaseV1 & {
+    readonly kind: 'enum';
+    readonly values: readonly string[];
+}) | (SimulationDynamicParameterDefinitionBaseV1 & {
+    readonly kind: 'actor-reference';
+    readonly allowSelf?: boolean;
+}) | (SimulationDynamicParameterDefinitionBaseV1 & {
+    readonly kind: 'object-reference';
+    readonly objectKinds: readonly string[];
+    readonly statuses?: readonly string[];
+    readonly ownedByActor?: boolean;
+    readonly requiredData?: Readonly<Record<string, string | number | boolean>>;
+    readonly requiredNumericData?: Readonly<Record<string, {
+        readonly minimum?: number;
+        readonly maximumExclusive?: number;
+    }>>;
+    /** Intent references must link to these exact action participants. */
+    readonly actorLinks?: {
+        readonly actor?: string;
+        readonly target?: string;
+    };
+    /** Named actors may bypass actor-link equality, but never link cardinality or other filters. */
+    readonly actorLinkExceptions?: readonly string[];
+    /** Require the peer to have one exact object link to this reference. */
+    readonly linkMatch?: {
+        readonly parameterId: string;
+        readonly relation: string;
+    };
+    /** Require the peer amount to fit this object's unused capacity. */
+    readonly capacityMatch?: {
+        readonly parameterId: string;
+        readonly amountKey: string;
+        readonly capacityKey: string;
+        readonly usedKey: string;
+        readonly excludePeerReferenceKey?: string;
+    };
+    /** Match this object's data key to one other required reference in the same record. */
+    readonly dataMatch?: {
+        readonly parameterId: string;
+        readonly key: string;
+        readonly otherKey: string;
+    };
+}) | (SimulationDynamicParameterDefinitionBaseV1 & {
+    readonly kind: 'object-reference-list';
+    readonly objectKinds: readonly string[];
+    readonly statuses?: readonly string[];
+    readonly ownedByActor?: boolean;
+    readonly requiredData?: Readonly<Record<string, string | number | boolean>>;
+    readonly requiredNumericData?: Readonly<Record<string, {
+        readonly minimum?: number;
+        readonly maximumExclusive?: number;
+    }>>;
+    /** Intent references must link to these exact action participants. */
+    readonly actorLinks?: {
+        readonly actor?: string;
+        readonly target?: string;
+    };
+    /** Named actors may bypass actor-link equality, but never link cardinality or other filters. */
+    readonly actorLinkExceptions?: readonly string[];
+    readonly minimumItems: number;
+    readonly maximumItems: number;
+}) | (SimulationDynamicParameterDefinitionBaseV1 & {
+    readonly kind: 'resource-reference';
+    readonly resourceIds: readonly string[];
+});
+export interface SimulationDynamicMechanicDefinitionV1 {
+    readonly id: string;
+    readonly description: string;
+    readonly actor: 'required' | 'optional' | 'game-master';
+    readonly target: 'none' | 'optional' | 'required';
+    readonly intentParameters: readonly SimulationDynamicParameterDefinitionV1[];
+    readonly resolutionParameters: readonly SimulationDynamicParameterDefinitionV1[];
+}
+export type SimulationDynamicObjectVisibilityV1 = {
+    readonly scope: 'world';
+} | {
+    readonly scope: 'shared';
+    readonly actorIds: readonly string[];
+} | {
+    readonly scope: 'private';
+};
+export interface SimulationDynamicDomainObjectLinkV1 {
+    readonly relation: string;
+    readonly targetType: 'actor' | 'object' | 'event' | 'document';
+    readonly targetId: string;
+}
+export interface SimulationDynamicDomainObjectV1 {
+    readonly id: string;
+    readonly kind: string;
+    readonly label: string;
+    readonly status: string;
+    readonly version: number;
+    readonly ownerActorId: string | null;
+    readonly visibility: SimulationDynamicObjectVisibilityV1;
+    readonly data: SimulationJsonObjectV1;
+    readonly links: readonly SimulationDynamicDomainObjectLinkV1[];
+    readonly provenance: {
+        readonly createdRevision: number;
+        readonly updatedRevision: number;
+        readonly eventId: string;
+        readonly actionId: string;
+    };
+}
+export type SimulationDynamicWorldEffectV1 = {
+    readonly operation: 'resource.change';
+    readonly actionId: string;
+    readonly resourceId: string;
+    readonly delta: number;
+} | {
+    readonly operation: 'fact.add' | 'fact.remove';
+    readonly actionId: string;
+    readonly fact: string;
+} | {
+    readonly operation: 'object.put';
+    readonly actionId: string;
+    readonly expectedVersion: number | null;
+    /** Compiler-owned transient scene retention; never retires native world records. */
+    readonly sceneRetention?: {
+        readonly version: 1;
+        readonly retiredIds: readonly string[];
+    };
+    readonly object: SimulationDynamicDomainObjectV1;
+};
+export interface SimulationDynamicWorldStateV1 {
+    resources: Record<string, number>;
+    facts: readonly string[];
+    domainObjects: readonly SimulationDynamicDomainObjectV1[];
+}
+export type SimulationDynamicTimelineKindV1 = 'player-action' | 'agent-action' | 'agent-interaction' | 'gm-event' | 'adjudication' | 'world-change' | 'ending' | 'story-review';
+export interface SimulationDynamicHistoryEntryV1 {
+    readonly storyReview?: StoryReviewReceiptV1;
+    readonly storyteller?: StorytellerReceiptV1;
+    readonly revision: number;
+    readonly eventId: string;
+    readonly kind: SimulationDynamicTimelineKindV1;
+    readonly title: string;
+    readonly summary: string;
+    readonly playerActionId: string | null;
+    readonly playerIntent?: string;
+    readonly characterProposals: readonly SimulationCharacterProposalV1[];
+    readonly gmProposal: SimulationGmProposalV1;
+    readonly acceptedActionIds: readonly string[];
+    readonly effects: readonly SimulationDynamicWorldEffectV1[];
+    readonly objectGraphBefore?: readonly SimulationDynamicObjectGraphNodeV1[];
+    readonly usedFallback: boolean;
+    readonly meetings?: readonly SimulationMeetingV1[];
+}
+export type SimulationDynamicObjectGraphNodeV1 = Pick<SimulationDynamicDomainObjectV1, 'id' | 'ownerActorId' | 'links'>;
+export interface SimulationCharacterCallV1 {
+    readonly deadlineVersion?: 2;
+    readonly requestVersion?: 2 | 3 | 4 | 5;
+    readonly privacyVersion?: 3;
+    readonly actorId: string;
+    readonly status: 'accepted' | 'rejected';
+    readonly failureCode?: string;
+    readonly inputDigest: string;
+    readonly systemDigest: string;
+    readonly outputDigest: string;
+    readonly outputBytes: number;
+    readonly fullProposalDigest?: string;
+    readonly proposalDigest?: string;
+    readonly timing: {
+        readonly startedAtMs: number;
+        readonly settledAtMs: number;
+    };
+}
+export interface SimulationCharacterRepairV1 {
+    /** Absent receipts retain the original correction instructions. */
+    readonly instructionVersion?: 2;
+    readonly actorId: string;
+    readonly proposalId: string;
+    readonly cause: 'input_privacy_violation';
+    readonly status: 'accepted' | 'rejected';
+    readonly requested: boolean;
+    readonly failureCode?: string;
+    readonly inputDigest: string;
+    readonly initialSystemDigest: string;
+    readonly repairSystemDigest: string;
+    readonly repairInputDigest?: string;
+    readonly repairMode?: 'bounded-rewrite' | 'legacy';
+    readonly initialPromptBytes: number;
+    readonly repairPromptBytes: number;
+    readonly firstOutputDigest: string;
+    readonly firstOutputBytes: number;
+    readonly firstElapsedMs: number;
+    readonly timing?: {
+        readonly startedAtMs: number;
+        readonly settledAtMs: number;
+    };
+    readonly timeoutMs: number;
+    readonly maxTokens: 768;
+    readonly outputDigest: string;
+    readonly outputBytes: number;
+    /** Stored canonical history identity, after bounded compaction. */
+    readonly proposalDigest?: string;
+    /** Full validated correction identity; absent in legacy receipts. */
+    readonly fullProposalDigest?: string;
+}
+export type SimulationCharacterRepairV2 = Omit<SimulationCharacterRepairV1, 'instructionVersion' | 'cause'> & {
+    readonly instructionVersion: 3 | 4;
+    readonly cause: 'input_privacy_violation' | 'private-knowledge-leak';
+};
+export interface SimulationInferenceSettlementV1 {
+    readonly startedAtMs: number;
+    readonly settledAtMs: number;
+    readonly outcome: 'completed' | 'failed' | 'timeout';
+    readonly failureCode?: string;
+}
+/** Native observations are committed with the beat, never reconstructed from capture files. */
+export interface SimulationNativeCallV1 {
+    readonly callId: number;
+    readonly phase: 'main' | 'actor-update' | 'choice-authoring' | 'choice-repair' | 'story-review' | 'character' | 'meeting-turn';
+    readonly requestSha256: string;
+    readonly requestedAtMs: number;
+    readonly timeoutMs: number;
+    readonly providerStartedAtMs: number;
+    readonly terminal?: {
+        readonly type: 'inference-response' | 'inference-failed';
+        readonly sha256: string;
+        readonly atMs: number;
+    };
+    readonly decode?: {
+        readonly type: 'inference-decoded' | 'inference-decode-failed';
+        readonly sha256: string;
+        readonly atMs: number;
+    };
+    readonly settlement?: SimulationInferenceSettlementV1 & {
+        readonly sha256: string;
+    };
+}
+export interface SimulationNativeGmCallV1 extends SimulationNativeCallV1 {
+    readonly phase: 'main' | 'actor-update' | 'choice-authoring' | 'choice-repair' | 'story-review';
+}
+export interface SimulationNativeParticipantCallV1 extends SimulationNativeCallV1 {
+    readonly phase: 'character' | 'meeting-turn';
+}
+export interface SimulationActorRepairV1 {
+    readonly version: 1;
+    readonly cause: 'input_privacy_violation';
+    readonly requested: boolean;
+    readonly status: 'accepted' | 'rejected';
+    readonly failureCode?: string;
+    readonly inputDigest: string;
+    readonly systemDigest: string;
+    readonly outputDigest: string;
+    readonly outputBytes: number;
+    readonly maxTokens: number;
+    readonly timeoutMs: number;
+    readonly deadlineAtMs: number;
+    readonly timing: {
+        readonly startedAtMs: number;
+        readonly settledAtMs: number;
+    };
+    readonly initialSystemDigest: string;
+    readonly initialPromptBytes: number;
+    readonly repairPromptBytes: number;
+}
+export type SimulationActorRepairV2 = Omit<SimulationActorRepairV1, 'version' | 'cause'> & {
+    readonly version: 2;
+    readonly cause: 'input_privacy_violation' | 'private-knowledge-leak';
+};
+export type SimulationActorRepairV3 = Omit<SimulationActorRepairV2, 'version'> & {
+    readonly version: 3;
+};
+export type SimulationActorRepairV4 = Omit<SimulationActorRepairV2, 'version'> & {
+    readonly version: 4;
+};
+export type SimulationPublicRepairV1 = Omit<SimulationActorRepairV2, 'version'> & {
+    readonly version: 1;
+    readonly phase: 'main' | 'choice-authoring';
+    readonly format: 'public-text-patch-1';
+    readonly initialInputDigest: string;
+    readonly initialOutputDigest: string;
+    readonly initialOutputBytes: number;
+};
+export type SimulationPublicRepairV6 = Omit<SimulationPublicRepairV1, 'version' | 'phase'> & {
+    readonly version: 6;
+    readonly phase: 'choice-authoring';
+};
+export type SimulationPublicRepairV5 = Omit<SimulationPublicRepairV1, 'version'> & {
+    readonly version: 5;
+};
+export type SimulationPublicRepairV4 = Omit<SimulationPublicRepairV1, 'version'> & {
+    readonly version: 4;
+};
+export type SimulationPublicRepairV3 = Omit<SimulationPublicRepairV1, 'version'> & {
+    readonly version: 3;
+};
+export type SimulationPublicRepairV2 = Omit<SimulationPublicRepairV1, 'version'> & {
+    readonly version: 2;
+};
+export interface SimulationMainIdentityV1 {
+    readonly version: 1;
+    readonly proposalId: string;
+    readonly eventId: string;
+}
+export type SimulationMainIdentityV2 = Omit<SimulationMainIdentityV1, 'version'> & {
+    readonly version: 2;
+};
+export interface SimulationDynamicAuditEntryV1 {
+    readonly mainIdentity?: SimulationMainIdentityV1 | SimulationMainIdentityV2;
+    readonly revision: number;
+    readonly proposalId: string;
+    readonly status: 'accepted' | 'rejected' | 'fallback';
+    readonly codes: readonly string[];
+    readonly characterRoute: 'gpt-5.6-luna:low' | SimulationRouterAuditRouteV1;
+    readonly gameMasterRoute: 'gpt-5.6-luna:low' | 'gpt-5.6-sol:low' | 'gpt-5.6-sol:none' | SimulationRouterAuditRouteV1;
+    readonly inputDigest: string;
+    readonly outputDigest: string;
+    readonly outputBytes: number;
+    readonly outputScope: 'full' | 'legacy-prefix';
+    readonly fallbackReason: string | null;
+    readonly nativeGmCalls?: readonly SimulationNativeGmCallV1[];
+    readonly nativeParticipantCalls?: readonly SimulationNativeParticipantCallV1[];
+    readonly characterCalls?: readonly SimulationCharacterCallV1[];
+    readonly characterRepairs?: readonly (SimulationCharacterRepairV1 | SimulationCharacterRepairV2)[];
+    readonly publicRepairs?: readonly (SimulationPublicRepairV1 | SimulationPublicRepairV2 | SimulationPublicRepairV3 | SimulationPublicRepairV4 | SimulationPublicRepairV5 | SimulationPublicRepairV6)[];
+    readonly actorUpdates?: {
+        readonly byteAllocation?: 'receipt-pool-v1';
+        readonly status: 'accepted' | 'fallback';
+        readonly entries: readonly {
+            readonly instructionVersion?: 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11;
+            readonly causeBindingVersion?: 3;
+            readonly actorId: string;
+            readonly sourceEventId: string;
+            readonly sourceActionIds: readonly string[];
+            readonly sourceAdjudicationProposalIds?: readonly string[];
+            readonly model: 'gpt-5.6-luna' | 'gpt-5.6-sol' | SimulationRouterModelV1;
+            readonly reasoningEffort: 'low' | 'none';
+            readonly requested: boolean;
+            readonly status: 'accepted' | 'rejected';
+            readonly failureCode?: string;
+            readonly inputDigest: string;
+            readonly outputDigest: string;
+            readonly outputBytes: number;
+            readonly maxTokens: number;
+            readonly repair?: SimulationActorRepairV1 | SimulationActorRepairV2 | SimulationActorRepairV3 | SimulationActorRepairV4;
+        }[];
+    };
+    readonly choiceAuthoring?: {
+        readonly status: 'accepted' | 'fallback';
+        readonly failureCode?: string;
+        readonly inputDigest: string;
+        readonly outputDigest: string;
+        readonly outputBytes: number;
+    };
+    readonly choiceRepair?: {
+        readonly cause: string;
+        readonly status: 'accepted' | 'rejected' | 'topped-up';
+        readonly failureCode?: string;
+        readonly inputDigest: string;
+        readonly outputDigest: string;
+        readonly outputBytes: number;
+    };
+    /** Private phrases the runtime withheld from public prose before the beat committed. */
+    readonly redacted?: number;
+    /** Autonomous or world actions the runtime dropped from the beat, with the rule each broke. */
+    readonly shed?: readonly {
+        readonly actionId: string;
+        readonly actorId?: string;
+        readonly mechanic: string;
+        readonly code: string;
+    }[];
+}
+export interface SimulationDynamicKnowledgeViewV1 {
+    readonly id: string;
+    readonly text: string;
+    readonly value?: number;
+    readonly visibility: Exclude<SimulationKnowledgeVisibilityV1, 'private'> | 'redacted';
+    readonly sourceEventId?: string;
+}
+export interface SimulationDynamicAgentViewV1 {
+    readonly id: string;
+    readonly name: string;
+    readonly role: string;
+    readonly humanControlled: boolean;
+    readonly mood: string;
+    readonly currentIntent: string | null;
+    readonly goals: readonly SimulationDynamicKnowledgeViewV1[];
+    readonly beliefs: readonly SimulationDynamicKnowledgeViewV1[];
+    readonly relationships: readonly SimulationDynamicKnowledgeViewV1[];
+    readonly memories: readonly SimulationDynamicKnowledgeViewV1[];
+    readonly resources: readonly SimulationDynamicKnowledgeViewV1[];
+    readonly recentAutonomousActions: readonly SimulationDynamicKnowledgeViewV1[];
+}
+export interface SimulationDynamicDomainObjectViewV1 {
+    readonly id: string;
+    readonly kind: string;
+    readonly label: string;
+    readonly status: string;
+    readonly version: number;
+    readonly ownerActorId: string | null;
+    readonly data: SimulationJsonObjectV1;
+    readonly links: readonly SimulationDynamicDomainObjectLinkV1[];
+    readonly updatedRevision: number;
+}
+export type SimulationDynamicWorldEffectViewV1 = {
+    readonly operation: 'resource.change';
+    readonly resourceId: string;
+    readonly resourceLabel: string;
+    readonly delta: number;
+    /** Absent in checkpoints written before effect causes were projected. */
+    readonly cause?: {
+        readonly actor: string;
+        readonly action: string;
+        readonly reason: string;
+    };
+} | {
+    readonly operation: 'fact.add' | 'fact.remove';
+    readonly fact: string;
+} | {
+    readonly operation: 'object.put';
+    readonly objectId: string;
+    readonly objectKind: string;
+    readonly objectLabel: string;
+    readonly status: string;
+    readonly version: number;
+    readonly expectedVersion: number | null;
+    readonly ownerActorId: string | null;
+};
+export interface SimulationDynamicPlayFrameV1 {
+    readonly storyReview?: StoryReviewViewV1;
+    readonly schemaVersion: 5;
+    readonly locations: SimulationInteractionStateV1['locations'];
+    readonly positions: SimulationInteractionStateV1['positions'];
+    readonly meetings: readonly SimulationMeetingV1[];
+    readonly storyteller: DynamicInitializationV1['storyteller'] | null;
+    /** Optional only for checkpoints written before player ruling projection. */
+    readonly playerDecision?: null | {
+        readonly label: string;
+        readonly playerActionId: string;
+        readonly outcome: 'succeeded' | 'partial' | 'failed';
+        readonly reason: string;
+    };
+    readonly gameKind: string;
+    readonly revision: number;
+    readonly status: SimulationDynamicRunStatusV1;
+    readonly safetyCeiling: {
+        readonly current: number;
+        readonly maximum: number;
+    };
+    readonly situation: {
+        readonly id?: string;
+        readonly title: string;
+        readonly narrative: string;
+        readonly urgency: 'low' | 'medium' | 'high' | 'critical';
+        readonly openQuestions: readonly string[];
+    };
+    readonly safeMode: {
+        readonly active: boolean;
+        readonly reason: string | null;
+    };
+    readonly pacing: SimulationGmProposalV1['pacing'];
+    readonly availableActions: readonly SimulationDynamicPlayerActionV1[];
+    readonly characterResponses: SimulationGmProposalV1['characterResponses'];
+    readonly agents: readonly SimulationDynamicAgentViewV1[];
+    readonly worldFacts: readonly string[];
+    readonly world: readonly {
+        readonly id: string;
+        readonly label: string;
+        readonly value: number;
+        readonly minimum: number;
+        readonly maximum: number;
+        /** The meter's starting value, so a reader can tell which way it has moved. */
+        readonly initial?: number;
+        readonly dangerDirection: SimulationDynamicResourceDefinitionV1['dangerDirection'];
+    }[];
+    readonly domainObjects: readonly SimulationDynamicDomainObjectViewV1[];
+    readonly latestEffects: readonly SimulationDynamicWorldEffectViewV1[];
+    readonly timeline: readonly {
+        readonly revision: number;
+        readonly eventId: string;
+        readonly kind: SimulationDynamicTimelineKindV1;
+        readonly title: string;
+        readonly summary: string;
+    }[];
+    readonly adjudications: readonly {
+        readonly proposalId: string;
+        readonly outcome: SimulationGmProposalV1['adjudications'][number]['outcome'];
+        readonly reason: string;
+        readonly actionIds: readonly string[];
+    }[];
+    readonly ending: SimulationGmProposalV1['ending'];
+}
+export interface DynamicHistoryReference {
+    readonly version: 1;
+    readonly identity: string;
+    readonly revision: number;
+    readonly digest: string;
+}
+export interface DynamicHistoryArchive {
+    readonly version: 1;
+    readonly genesis: DynamicHistoryReference;
+    readonly head: DynamicHistoryReference;
+}
+export interface SimulationDynamicStateV1 {
+    readonly episode?: StoryEpisodeV1;
+    readonly agencyVersion?: 'emergent-v1';
+    readonly historyArchive?: DynamicHistoryArchive;
+    readonly schemaVersion: 11;
+    readonly interaction: SimulationInteractionStateV1;
+    readonly initialization: DynamicInitialization | null;
+    readonly gameKind: string;
+    readonly rulesVersion: string;
+    readonly seed: string;
+    readonly revision: number;
+    readonly status: SimulationDynamicRunStatusV1;
+    readonly safetyCeiling: number;
+    readonly world: SimulationDynamicWorldStateV1;
+    readonly agents: readonly SimulationPersistentAgentStateV1[];
+    readonly history: readonly SimulationDynamicHistoryEntryV1[];
+    readonly audit: readonly SimulationDynamicAuditEntryV1[];
+    readonly frame: SimulationDynamicPlayFrameV1;
+}
+export interface SimulationDynamicInferenceCallV1 {
+    readonly role: 'character' | 'game-master';
+    readonly model: 'gpt-5.6-luna' | 'gpt-5.6-sol';
+    readonly reasoningEffort: 'low' | 'none';
+    readonly maxTokens: number;
+    readonly timeoutMs: number;
+    readonly system: string;
+    readonly input: string;
+}
+/** The one Router model a simulation may run on. */
+export type SimulationRouterModelV1 = 'modal/deepseek-v4.1-flash';
+/** Audit route recorded for every role when the Router model serves a beat. */
+export type SimulationRouterAuditRouteV1 = 'zergrouter:modal/deepseek-v4.1-flash';
+/** The provider and model that actually serve an inference boundary. */
+export interface SimulationServingRouteV1 {
+    readonly provider: 'zergrouter';
+    readonly model: SimulationRouterModelV1;
+}
+export interface SimulationDynamicInferenceV1 {
+    /** Set when the calls are served by a Router model. Receipts then record it instead of the logical Codex tier. */
+    readonly servingRoute?: SimulationServingRouteV1;
+    complete(call: SimulationDynamicInferenceCallV1): Promise<string>;
+    onSettled?(call: SimulationDynamicInferenceCallV1, settlement: SimulationInferenceSettlementV1): void;
+    nativeGmCalls?(): readonly SimulationNativeGmCallV1[];
+    nativeParticipantCalls?(): readonly SimulationNativeParticipantCallV1[];
+}
 export interface SimulationProgressNotificationV1 {
     readonly type: 'progress';
     readonly session: SimulationSessionRefV1;
@@ -188,6 +985,8 @@ export interface SimulationWorldPatchV1 {
     readonly world?: SimulationJsonObjectV1;
 }
 export interface SimulationDocumentWriteV1 {
+    readonly provenance?: SimulationDocumentProvenanceV1;
+    readonly ownerActorId?: string;
     readonly operation: 'document.write';
     readonly label: string;
     readonly documentType: string;
@@ -221,12 +1020,21 @@ export interface SimulationPluginDataWriteV1 {
     readonly namespace: string;
     readonly value: SimulationJsonObjectV1;
 }
-export type SimulationTransitionOperationV1 = SimulationDocumentWriteV1 | SimulationDocumentCommentV1 | SimulationWorldWriteV1 | SimulationPluginDataWriteV1;
+export interface SimulationDynamicStateCommitV1 {
+    readonly operation: 'dynamic-state.commit';
+    readonly state: SimulationDynamicStateV1;
+}
+export type SimulationTransitionOperationV1 = {
+    readonly operation: 'session-inputs.resolve';
+    readonly sealedDigest: string;
+    readonly resolutions: readonly import('./simulation_interventions.js').SimulationInterventionResolutionV1[];
+} | SimulationDocumentWriteV1 | SimulationDocumentCommentV1 | SimulationWorldWriteV1 | SimulationPluginDataWriteV1 | SimulationDynamicStateCommitV1;
 export interface SimulationTransitionBatchV1 {
     readonly kind: string;
     readonly expectedRevision: number;
     readonly idempotencyKey: string;
     readonly periodNumber?: number;
+    readonly advanceTimeSteps?: number;
     readonly operations: readonly SimulationTransitionOperationV1[];
 }
 export interface SimulationTransitionResultV1 {
@@ -237,9 +1045,29 @@ export interface SimulationTransitionResultV1 {
 export interface SimulationDriverAuthorityV1 {
     applyTransition(batch: SimulationTransitionBatchV1): Promise<SimulationTransitionResultV1>;
 }
+export interface SimulationDefinitionV1 {
+    readonly kind: string;
+    readonly title: string;
+    readonly summary: string;
+    readonly objective: string;
+    readonly maxTurns: number;
+    readonly estimatedMinutes: number;
+    readonly playerRoles: readonly string[];
+    readonly mechanics: readonly string[];
+}
+export interface SimulationPlayerCommandV1 {
+    readonly commandId: string;
+    readonly kind: string;
+    readonly actorId?: string;
+    readonly payload: SimulationJsonObjectV1;
+}
+export interface SimulationPlayerCommandResultV1 {
+    readonly accepted: boolean;
+}
 export interface SimulationDriverContextV1 {
     readonly session: SimulationSessionV1;
     readonly authority: SimulationDriverAuthorityV1;
+    readonly playerCommand: SimulationPlayerCommandV1 | null;
     readonly signal: AbortSignal;
     notify(notification: SimulationNotificationV1): void;
     completeInference(request: SimulationInferenceRequestV1): Promise<SimulationInferenceResultV1>;
@@ -252,15 +1080,21 @@ export interface SimulationDriverV1 {
     rehydrate?(context: SimulationDriverContextV1, checkpointPath: string): void | Promise<void>;
 }
 export interface SimulationDriverRegistrationV1 {
+    readonly initializeDocuments?: (state: SimulationDynamicStateV1) => readonly SimulationDocumentWriteV1[];
+    readonly validateDocuments?: (snapshot: SimulationSessionSnapshotV1) => void;
+    readonly validateDynamicState?: (state: SimulationDynamicStateV1) => void;
     readonly kind: string;
     readonly compatibility: SimulationCompatibilityV1;
+    readonly definition?: SimulationDefinitionV1;
     loadDriver(): Promise<SimulationDriverV1>;
 }
 export interface SimulationHostV1 {
     readonly capabilities: SimulationHostCapabilitiesV1;
+    listSimulationDefinitions(): readonly SimulationDefinitionV1[];
     createSession(request: SimulationCreateSessionRequestV1): Promise<SimulationSessionV1>;
     loadSession(request: SimulationLoadSessionRequestV1): Promise<SimulationSessionV1>;
     getSession(ref: SimulationSessionRefV1): SimulationSessionV1 | null;
+    submitPlayerCommand(ref: SimulationSessionRefV1, command: SimulationPlayerCommandV1): Promise<SimulationPlayerCommandResultV1>;
     startSession(request: SimulationStartSessionRequestV1): Promise<void>;
     stopSession(ref: SimulationSessionRefV1): Promise<void>;
     checkpoint(request: SimulationCheckpointRequestV1): Promise<SimulationCheckpointRefV1>;
@@ -271,3 +1105,4 @@ export interface SimulationPluginActivationContextV1 {
     requireHost(compatibility: SimulationCompatibilityV1): SimulationHostV1;
     register(registration: SimulationDriverRegistrationV1): void;
 }
+export {};