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

package/dist/simulation/toolkit/dynamic_meetings.d.ts

@@ -0,0 +1,239 @@
+import { z } from 'zod';
+import type { SimulationCharacterProposalV1, SimulationDynamicMechanicDefinitionV1, SimulationDynamicWorldStateV1, SimulationPersistentAgentStateV1, SimulationDynamicHistoryEntryV1, SimulationDynamicInferenceCallV1, SimulationDynamicIntentActivityV1, SimulationDynamicStateV1, SimulationGmProposalV1, SimulationServingRouteV1 } from '../../plugin/simulation_contract.js';
+import type { SimulationInteractionPolicyV1, SimulationInteractionStateV1, SimulationMeetingActivityV1, SimulationMeetingChoiceV1, SimulationMeetingV1 } from '../../plugin/simulation_meetings.js';
+export declare const locationSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    kind: z.ZodEnum<{
+        field: "field";
+        "meeting-room": "meeting-room";
+        workplace: "workplace";
+        transit: "transit";
+    }>;
+    domainObjectId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const positionSchema: z.ZodObject<{
+    actorId: z.ZodString;
+    locationId: z.ZodNullable<z.ZodString>;
+    revision: z.ZodNumber;
+    cause: z.ZodNullable<z.ZodObject<{
+        kind: z.ZodEnum<{
+            action: "action";
+            initial: "initial";
+            meeting: "meeting";
+        }>;
+        sourceId: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const interactionPolicySchema: z.ZodObject<{
+    version: z.ZodEnum<{
+        "meetings-1": "meetings-1";
+        "meetings-2": "meetings-2";
+    }>;
+    locations: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        kind: z.ZodEnum<{
+            field: "field";
+            "meeting-room": "meeting-room";
+            workplace: "workplace";
+            transit: "transit";
+        }>;
+        domainObjectId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    initialActorLocations: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>;
+    meetingLocationId: z.ZodString;
+    issue: z.ZodObject<{
+        title: z.ZodString;
+        domainObjectIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    actionLocations: z.ZodArray<z.ZodObject<{
+        mechanic: z.ZodString;
+        location: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"fixed">;
+            locationId: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"object">;
+            intentParameter: z.ZodString;
+            objectLocations: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const interactionSchema: z.ZodObject<{
+    policyVersion: z.ZodNullable<z.ZodEnum<{
+        "meetings-1": "meetings-1";
+        "meetings-2": "meetings-2";
+    }>>;
+    policy: z.ZodNullable<z.ZodObject<{
+        version: z.ZodEnum<{
+            "meetings-1": "meetings-1";
+            "meetings-2": "meetings-2";
+        }>;
+        locations: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            kind: z.ZodEnum<{
+                field: "field";
+                "meeting-room": "meeting-room";
+                workplace: "workplace";
+                transit: "transit";
+            }>;
+            domainObjectId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        initialActorLocations: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>;
+        meetingLocationId: z.ZodString;
+        issue: z.ZodObject<{
+            title: z.ZodString;
+            domainObjectIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        actionLocations: z.ZodArray<z.ZodObject<{
+            mechanic: z.ZodString;
+            location: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"fixed">;
+                locationId: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"object">;
+                intentParameter: z.ZodString;
+                objectLocations: z.ZodRecord<z.ZodString, z.ZodString>;
+            }, z.core.$strict>], "kind">;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    locations: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        kind: z.ZodEnum<{
+            field: "field";
+            "meeting-room": "meeting-room";
+            workplace: "workplace";
+            transit: "transit";
+        }>;
+        domainObjectId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    positions: z.ZodArray<z.ZodObject<{
+        actorId: z.ZodString;
+        locationId: z.ZodNullable<z.ZodString>;
+        revision: z.ZodNumber;
+        cause: z.ZodNullable<z.ZodObject<{
+            kind: z.ZodEnum<{
+                action: "action";
+                initial: "initial";
+                meeting: "meeting";
+            }>;
+            sourceId: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const meetingTurnSchema: z.ZodObject<{
+    meetingId: z.ZodString;
+    turnId: z.ZodString;
+    speakerActorId: z.ZodString;
+    predecessorTurnId: z.ZodNullable<z.ZodString>;
+    text: z.ZodString;
+    candidateChoiceId: z.ZodNullable<z.ZodEnum<{
+        "proceed-both": "proceed-both";
+        "proceed-first": "proceed-first";
+        "proceed-second": "proceed-second";
+    }>>;
+    endMeeting: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const meetingSchema: z.ZodObject<{
+    invitation: z.ZodOptional<z.ZodObject<{
+        sourceProposalId: z.ZodString;
+        authorActorId: z.ZodString;
+        recipientActorId: z.ZodString;
+    }, z.core.$strict>>;
+    meetingId: z.ZodString;
+    revision: z.ZodNumber;
+    issue: z.ZodString;
+    locationId: z.ZodString;
+    participantActorIds: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+    audienceActorIds: z.ZodArray<z.ZodString>;
+    sourceProposalIds: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+    turns: z.ZodArray<z.ZodObject<{
+        meetingId: z.ZodString;
+        turnId: z.ZodString;
+        speakerActorId: z.ZodString;
+        predecessorTurnId: z.ZodNullable<z.ZodString>;
+        text: z.ZodString;
+        candidateChoiceId: z.ZodNullable<z.ZodEnum<{
+            "proceed-both": "proceed-both";
+            "proceed-first": "proceed-first";
+            "proceed-second": "proceed-second";
+        }>>;
+        endMeeting: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    receipts: z.ZodArray<z.ZodObject<{
+        requestVersion: z.ZodOptional<z.ZodLiteral<2>>;
+        instructionVersion: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<2>, z.ZodLiteral<3>]>>;
+        turnId: z.ZodString;
+        speakerActorId: z.ZodString;
+        predecessorTurnId: z.ZodNullable<z.ZodString>;
+        requested: z.ZodBoolean;
+        durationMs: z.ZodNumber;
+        priorTurnsDigest: z.ZodString;
+        turnDigest: z.ZodNullable<z.ZodString>;
+        provider: z.ZodEnum<{
+            zergrouter: "zergrouter";
+            codex_legacy: "codex_legacy";
+        }>;
+        role: z.ZodLiteral<"character">;
+        model: z.ZodEnum<{
+            "gpt-5.6-luna": "gpt-5.6-luna";
+            "modal/deepseek-v4.1-flash": "modal/deepseek-v4.1-flash";
+        }>;
+        reasoningEffort: z.ZodLiteral<"low">;
+        status: z.ZodEnum<{
+            accepted: "accepted";
+            rejected: "rejected";
+            declined: "declined";
+        }>;
+        failureCode: z.ZodOptional<z.ZodString>;
+        inputDigest: z.ZodString;
+        outputDigest: z.ZodString;
+        outputBytes: z.ZodNumber;
+        maxTokens: z.ZodLiteral<512>;
+    }, z.core.$strict>>;
+    status: z.ZodEnum<{
+        accepted: "accepted";
+        rejected: "rejected";
+    }>;
+    decision: z.ZodNullable<z.ZodObject<{
+        id: z.ZodEnum<{
+            "proceed-both": "proceed-both";
+            "proceed-first": "proceed-first";
+            "proceed-second": "proceed-second";
+        }>;
+        proceedProposalIds: z.ZodArray<z.ZodString>;
+        deferProposalIds: z.ZodArray<z.ZodString>;
+        finalTurnId: z.ZodString;
+    }, z.core.$strict>>;
+    failureCode: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare class DynamicMeetingError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export declare function initialInteraction(policy: SimulationInteractionPolicyV1 | undefined, actors: readonly {
+    actorId: string;
+}[]): SimulationInteractionStateV1;
+export declare function meetingChoices(ids: readonly [string, string]): readonly SimulationMeetingChoiceV1[];
+export declare function dynamicMeetingSystemPrompt(version?: 1 | 2 | 3): string;
+export declare function conductDynamicMeeting(input: {
+    state: SimulationDynamicStateV1;
+    proposals: readonly SimulationCharacterProposalV1[];
+    publicIntents: readonly SimulationDynamicIntentActivityV1[];
+    complete: (call: SimulationDynamicInferenceCallV1) => Promise<string>;
+    servingRoute?: SimulationServingRouteV1;
+    assertPublic: (value: unknown) => void;
+    speakerContext?: (actorId: string, publicRequest: Record<string, unknown>) => Record<string, unknown>;
+    privateSpeakerContext?: boolean;
+    requestVersion?: 2;
+    onActivity?: (activity: SimulationMeetingActivityV1) => Promise<void>;
+}): Promise<readonly SimulationMeetingV1[]>;
+export declare function moveDynamicActors(interaction: SimulationInteractionStateV1, meetings: readonly SimulationMeetingV1[], actions: SimulationGmProposalV1['domainActions'], revision: number): SimulationInteractionStateV1;
+export declare function validateInteractionPolicy(policy: SimulationInteractionPolicyV1 | undefined, world: SimulationDynamicWorldStateV1, actors: readonly SimulationPersistentAgentStateV1[], mechanics: readonly SimulationDynamicMechanicDefinitionV1[]): void;
+export declare function validateMeetingHistory(entry: SimulationDynamicHistoryEntryV1, interaction: SimulationInteractionStateV1, actors: readonly SimulationPersistentAgentStateV1[], agencyVersion?: 'emergent-v1'): void;
+export declare function validateMeetingAdjudications(proposal: Pick<SimulationGmProposalV1, 'adjudications' | 'domainActions'>, meetings: readonly SimulationMeetingV1[], characters: readonly {
+    readonly proposalId: string;
+    readonly attemptedActions: readonly Pick<SimulationCharacterProposalV1['attemptedActions'][number], 'mechanic' | 'parameters'>[];
+}[], agencyVersion?: 'emergent-v1'): void;

package/dist/simulation/toolkit/dynamic_meetings.js

@@ -0,0 +1,350 @@
+import { isDeepStrictEqual } from 'node:util';
+import { z } from 'zod';
+import { digestDynamicText as digest } from './dynamic_digest.js';
+import { dynamicObjectVisibleToActor } from './dynamic_projection.js';
+const id = z.string().trim().min(1).max(128);
+const text = (max) => z.string().trim().min(1).max(max);
+const choiceId = z.enum(['proceed-both', 'proceed-first', 'proceed-second']);
+export const locationSchema = z.object({ id, name: text(160), kind: z.enum(['meeting-room', 'workplace', 'transit', 'field']), domainObjectId: id.optional() }).strict();
+export const positionSchema = z.object({ actorId: id, locationId: id.nullable(), revision: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER), cause: z.object({ kind: z.enum(['initial', 'action', 'meeting']), sourceId: id }).strict().nullable() }).strict();
+export const interactionPolicySchema = z.object({
+    version: z.enum(['meetings-1', 'meetings-2']), locations: z.array(locationSchema).min(1).max(32),
+    initialActorLocations: z.record(id, id.nullable()), meetingLocationId: id,
+    issue: z.object({ title: text(240), domainObjectIds: z.array(id).min(1).max(8) }).strict(),
+    actionLocations: z.array(z.object({ mechanic: id, location: z.discriminatedUnion('kind', [
+            z.object({ kind: z.literal('fixed'), locationId: id }).strict(),
+            z.object({ kind: z.literal('object'), intentParameter: id, objectLocations: z.record(id, id) }).strict(),
+        ]) }).strict()).max(32),
+}).strict();
+export const interactionSchema = z.object({ policyVersion: z.enum(['meetings-1', 'meetings-2']).nullable(), policy: interactionPolicySchema.nullable(), locations: z.array(locationSchema).max(32), positions: z.array(positionSchema).min(3).max(8) }).strict();
+const legacyMeetingTurnSchema = z.object({ meetingId: id, turnId: id, speakerActorId: id, predecessorTurnId: id.nullable(), text: text(600), candidateChoiceId: choiceId }).strict();
+export const meetingTurnSchema = legacyMeetingTurnSchema.extend({ candidateChoiceId: choiceId.nullable(), endMeeting: z.boolean().optional() });
+const voluntaryResponseSchema = meetingTurnSchema.extend({ text: z.string().trim().max(600) });
+const receiptSchema = z.object({
+    requestVersion: z.literal(2).optional(),
+    instructionVersion: z.union([z.literal(2), z.literal(3)]).optional(),
+    turnId: id, speakerActorId: id, predecessorTurnId: id.nullable(), requested: z.boolean(), durationMs: z.number().int().min(0).max(240000), priorTurnsDigest: z.string().regex(/^[a-f0-9]{8}$/), turnDigest: z.string().regex(/^[a-f0-9]{8}$/).nullable(),
+    provider: z.enum(['codex_legacy', 'zergrouter']), role: z.literal('character'), model: z.enum(['gpt-5.6-luna', 'modal/deepseek-v4.1-flash']), reasoningEffort: z.literal('low'),
+    status: z.enum(['accepted', 'declined', 'rejected']), failureCode: id.optional(), inputDigest: z.string().regex(/^[a-f0-9]{8}$/), outputDigest: z.string().regex(/^[a-f0-9]{8}$/), outputBytes: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER), maxTokens: z.literal(512),
+}).strict();
+const invitationSchema = z.object({ sourceProposalId: id, authorActorId: id, recipientActorId: id }).strict();
+export const meetingSchema = z.object({
+    invitation: invitationSchema.optional(),
+    meetingId: id, revision: z.number().int().min(1).max(Number.MAX_SAFE_INTEGER), issue: text(240), locationId: id,
+    participantActorIds: z.tuple([id, id]), audienceActorIds: z.array(id).min(3).max(8), sourceProposalIds: z.tuple([id, id]),
+    turns: z.array(meetingTurnSchema).max(3), receipts: z.array(receiptSchema).max(3), status: z.enum(['accepted', 'rejected']),
+    decision: z.object({ id: choiceId, proceedProposalIds: z.array(id).min(1).max(2), deferProposalIds: z.array(id).max(1), finalTurnId: id }).strict().nullable(),
+    failureCode: id.optional(),
+}).strict();
+export class DynamicMeetingError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'DynamicMeetingError';
+    }
+}
+function fail(code, message) { throw new DynamicMeetingError(code, message); }
+export function initialInteraction(policy, actors) {
+    if (policy === undefined)
+        return { policyVersion: null, policy: null, locations: [], positions: actors.map(actor => ({ actorId: actor.actorId, locationId: null, revision: 0, cause: null })) };
+    const parsed = interactionPolicySchema.safeParse(policy);
+    if (!parsed.success)
+        fail('interaction-policy-invalid', 'Interaction policy is malformed');
+    if (!isDeepStrictEqual(Object.keys(policy.initialActorLocations).sort(), actors.map(actor => actor.actorId).sort()))
+        fail('interaction-policy-invalid', 'Initial locations must name every actor exactly once');
+    const locations = new Set(policy.locations.map(location => location.id));
+    if (locations.size !== policy.locations.length || !locations.has(policy.meetingLocationId)
+        || Object.values(policy.initialActorLocations).some(location => location !== null && !locations.has(location))
+        || policy.actionLocations.some(mapping => mapping.location.kind === 'fixed' ? !locations.has(mapping.location.locationId) : Object.values(mapping.location.objectLocations).some(location => !locations.has(location))))
+        fail('interaction-policy-invalid', 'Interaction locations must be unique and references must resolve');
+    return { policyVersion: policy.version, policy: structuredClone(policy), locations: structuredClone(policy.locations), positions: actors.map(actor => {
+            const locationId = policy.initialActorLocations[actor.actorId];
+            return { actorId: actor.actorId, locationId, revision: 0, cause: locationId === null ? null : { kind: 'initial', sourceId: policy.version } };
+        }) };
+}
+export function meetingChoices(ids) {
+    return [
+        { id: 'proceed-both', proceedProposalIds: [...ids], deferProposalIds: [] },
+        { id: 'proceed-first', proceedProposalIds: [ids[0]], deferProposalIds: [ids[1]] },
+        { id: 'proceed-second', proceedProposalIds: [ids[1]], deferProposalIds: [ids[0]] },
+    ];
+}
+export function dynamicMeetingSystemPrompt(version = 2) {
+    if (version === 3)
+        return 'You may speak, decline, or stay silent. Empty text declines this discussion without speech. Set endMeeting to true to leave after speaking. candidateChoiceId may be null; listed plans are suggestions, not agreements or orders. No speaker decides for another. Return only the declared schema.';
+    return version === 1
+        ? 'Speak as the assigned participant. Discuss the shared issue, proposals and prior turns. Choose a listed plan; the last speaker decides. Propose actions without claiming they occurred. Return only the declared schema.'
+        : 'Speak as assigned in short, complete sentences. Match speech to the chosen plan: proceed means act now; defer pending conditions. Final speaker decides. Never claim execution. Return only the declared schema.';
+}
+export async function conductDynamicMeeting(input) {
+    const { state } = input;
+    const voluntary = state.agencyVersion === 'emergent-v1';
+    const instructionVersion = voluntary ? 3 : 2;
+    const policy = state.interaction.policy;
+    if (policy === null)
+        return [];
+    const authored = policy.version === 'meetings-2';
+    const author = authored ? input.proposals.find(proposal => proposal.discussionInvitation != null) : undefined;
+    if (authored && author === undefined)
+        return [];
+    const recipient = author === undefined ? undefined : input.proposals.find(proposal => proposal.actorId === author.discussionInvitation.recipientActorId);
+    if (author !== undefined && (recipient === undefined || recipient.actorId === author.actorId
+        || [author, recipient].some(proposal => proposal.basedOnRevision !== state.revision
+            || !state.agents.some(actor => actor.actorId === proposal.actorId && !actor.humanControlled))))
+        fail('meeting-invitation-invalid', 'An invitation must link its author and a current autonomous recipient');
+    const invitation = author === undefined ? undefined : { sourceProposalId: author.proposalId, authorActorId: author.actorId, recipientActorId: recipient.actorId };
+    const eligible = authored ? [recipient, author].map(proposal => ({
+        actorId: proposal.actorId, actorName: state.agents.find(actor => actor.actorId === proposal.actorId).name,
+        sourceProposalId: proposal.proposalId,
+    })) : input.publicIntents.filter(intent => {
+        const proposal = input.proposals.find(item => item.proposalId === intent.sourceProposalId);
+        const actor = state.agents.find(item => item.actorId === proposal.actorId);
+        return actor.goals.some(goal => goal.id === proposal.intent?.goalId && goal.visibility !== 'private');
+    });
+    if (eligible.length < 2)
+        return [];
+    const pair = eligible.slice(0, 2);
+    const audience = [...new Set([...pair.map(item => item.actorId), ...state.agents.filter(actor => actor.humanControlled).map(actor => actor.actorId)])];
+    const objects = policy.issue.domainObjectIds.map(objectId => state.world.domainObjects.find(object => object.id === objectId));
+    if (!authored && objects.some(object => object === undefined || audience.some(actor => !dynamicObjectVisibleToActor(object, actor))))
+        return [];
+    const location = policy.locations.find(item => item.id === policy.meetingLocationId);
+    const meetingId = `meeting-${state.revision + 1}`;
+    const sourceProposalIds = [pair[0].sourceProposalId, pair[1].sourceProposalId];
+    const issue = author?.discussionInvitation?.topic ?? policy.issue.title;
+    const base = { ...(invitation === undefined ? {} : { invitation }), meetingId, revision: state.revision + 1, issue, locationId: location.id,
+        participantActorIds: [pair[0].actorId, pair[1].actorId], audienceActorIds: audience, sourceProposalIds };
+    const forming = { ...(invitation === undefined ? {} : { invitation }), kind: 'meeting-forming', meetingId, basedOnRevision: state.revision, status: 'pending', validation: 'ztc-simulation-meeting-plan', locationId: location.id, locationName: location.name, issue, participants: pair.map(item => ({ actorId: item.actorId, actorName: item.actorName })) };
+    try {
+        input.assertPublic(forming);
+    }
+    catch {
+        return [];
+    }
+    await input.onActivity?.(forming);
+    const turns = [];
+    const receipts = [];
+    const choices = authored ? [] : meetingChoices(sourceProposalIds);
+    for (let index = 0; index < 3; index++) {
+        const speaker = pair[index === 1 ? 1 : 0];
+        const turnId = `${meetingId}-turn-${index + 1}`;
+        const predecessorTurnId = turns.at(-1)?.turnId ?? null;
+        const publicRequest = {
+            ...(input.requestVersion === undefined ? {} : { requestVersion: input.requestVersion }),
+            schemaVersion: 1, phase: 'meeting-turn',
+            meeting: { ...base, locationName: location.name, ...(authored ? {} : { proposals: pair.map(item => { const activity = input.publicIntents.find(intent => intent.sourceProposalId === item.sourceProposalId); return { proposalId: item.sourceProposalId, actorId: item.actorId, mechanic: activity.mechanic, intent: activity.text }; }) }), choices },
+            speaker: { actorId: speaker.actorId, name: speaker.actorName },
+            turn: { index, turnId, predecessorTurnId, purpose: voluntary ? 'continue-or-leave' : index === 0 ? 'propose' : index === 1 ? 'respond' : 'decide' },
+            priorTurns: structuredClone(turns),
+            responseSchema: { type: 'object', additionalProperties: false, required: ['meetingId', 'turnId', 'speakerActorId', 'predecessorTurnId', 'text', 'candidateChoiceId'], properties: {
+                    meetingId: { const: meetingId }, turnId: { const: turnId }, speakerActorId: { const: speaker.actorId }, predecessorTurnId: { const: predecessorTurnId }, text: { type: 'string', minLength: voluntary ? 0 : 1, maxLength: 600 }, candidateChoiceId: { enum: [...choices.map(choice => choice.id), ...(voluntary ? [null] : [])] },
+                    ...(voluntary ? { endMeeting: { type: 'boolean' } } : {}),
+                } },
+        };
+        const request = { ...publicRequest, ...(input.speakerContext === undefined ? {} : { speakerContext: input.speakerContext(speaker.actorId, publicRequest) }) };
+        const encoded = JSON.stringify(request);
+        if (Buffer.byteLength(encoded, 'utf8') > 65536)
+            fail('meeting-input-too-large', 'Meeting input exceeds the character request limit');
+        let raw = '';
+        let requested = false;
+        const startedAt = Date.now();
+        let turn = null;
+        let failureCode;
+        try {
+            input.assertPublic(input.privateSpeakerContext ? publicRequest : request);
+            requested = true;
+            raw = await input.complete({ role: 'character', model: 'gpt-5.6-luna', reasoningEffort: 'low', maxTokens: 512, timeoutMs: 20000,
+                system: dynamicMeetingSystemPrompt(instructionVersion), input: encoded });
+            if (Buffer.byteLength(raw, 'utf8') > 4096)
+                fail('meeting-output-too-large', 'Meeting output exceeds the character response limit');
+            const parsed = (voluntary ? voluntaryResponseSchema : legacyMeetingTurnSchema).safeParse(JSON.parse(raw));
+            if (!parsed.success)
+                fail('meeting-turn-invalid', 'Meeting turn is malformed');
+            turn = parsed.data;
+            if (authored && turn.candidateChoiceId !== null)
+                fail('meeting-turn-invalid', 'An invitation does not propose a binding plan');
+            if (turn.meetingId !== meetingId || turn.turnId !== turnId || turn.speakerActorId !== speaker.actorId || turn.predecessorTurnId !== predecessorTurnId)
+                fail('meeting-turn-lineage-invalid', 'Meeting turn must match its assigned speaker and predecessor');
+            input.assertPublic(turn);
+        }
+        catch (error) {
+            turn = null;
+            failureCode = error instanceof Error && 'code' in error && typeof error.code === 'string' ? error.code : 'meeting-turn-rejected';
+        }
+        const declined = voluntary && turn?.text === '';
+        receipts.push({ ...(input.requestVersion === undefined ? {} : { requestVersion: input.requestVersion }), instructionVersion, requested, durationMs: Math.max(0, Date.now() - startedAt), turnId, speakerActorId: speaker.actorId, predecessorTurnId, priorTurnsDigest: digest(JSON.stringify(turns)), turnDigest: turn === null || declined ? null : digest(JSON.stringify(turn)), provider: input.servingRoute?.provider ?? 'codex_legacy', role: 'character', model: input.servingRoute?.model ?? 'gpt-5.6-luna', reasoningEffort: 'low', status: turn === null ? 'rejected' : declined ? 'declined' : 'accepted', ...(failureCode === undefined ? {} : { failureCode }), inputDigest: digest(encoded), outputDigest: digest(raw), outputBytes: Buffer.byteLength(raw, 'utf8'), maxTokens: 512 });
+        if (turn === null)
+            return [{ ...base, turns, receipts, status: 'rejected', decision: null, failureCode: failureCode }];
+        if (declined)
+            return [{ ...base, turns, receipts, status: 'accepted', decision: null }];
+        turns.push(turn);
+        await input.onActivity?.({ ...turn, kind: 'meeting-turn', basedOnRevision: state.revision, status: 'pending', validation: 'ztc-simulation-meeting-turn', speakerName: speaker.actorName });
+        if (voluntary && turn.endMeeting)
+            return [{ ...base, turns, receipts, status: 'accepted', decision: null }];
+    }
+    if (voluntary)
+        return [{ ...base, turns, receipts, status: 'accepted', decision: null }];
+    const final = turns[2];
+    return [{ ...base, turns, receipts, status: 'accepted', decision: { ...choices.find(choice => choice.id === final.candidateChoiceId), finalTurnId: final.turnId } }];
+}
+export function moveDynamicActors(interaction, meetings, actions, revision) {
+    if (interaction.policy === null)
+        return structuredClone(interaction);
+    const positions = new Map(interaction.positions.map(position => [position.actorId, structuredClone(position)]));
+    for (const meeting of meetings)
+        if (meeting.status === 'accepted' && !meeting.receipts.some(receipt => receipt.instructionVersion === 3))
+            for (const actorId of meeting.participantActorIds)
+                positions.set(actorId, { actorId, locationId: meeting.locationId, revision, cause: { kind: 'meeting', sourceId: meeting.meetingId } });
+    for (const action of actions) {
+        if (action.mechanic === 'act-freely' || action.mechanic === 'world-scene') {
+            const resolution = action.parameters.resolution;
+            if (resolution && typeof resolution === 'object' && !Array.isArray(resolution) && 'scene' in resolution && typeof resolution.scene === 'string') {
+                const scene = JSON.parse(resolution.scene);
+                for (const move of scene.moves ?? []) {
+                    if (!positions.has(move.actorId) || !interaction.locations.some(location => location.id === move.locationId))
+                        fail('scene-movement-invalid', 'A scene move requires a known actor and location');
+                    positions.set(move.actorId, { actorId: move.actorId, locationId: move.locationId, revision, cause: { kind: 'action', sourceId: action.id } });
+                }
+            }
+        }
+        if (action.actorId === undefined)
+            continue;
+        const mapping = interaction.policy.actionLocations.find(item => item.mechanic === action.mechanic);
+        if (mapping === undefined)
+            continue;
+        const intent = action.parameters.intent;
+        const target = mapping.location.kind === 'object' && intent !== null && typeof intent === 'object' && !Array.isArray(intent) ? intent[mapping.location.intentParameter] : undefined;
+        const locationId = mapping.location.kind === 'fixed' ? mapping.location.locationId : typeof target === 'string' ? mapping.location.objectLocations[target] : undefined;
+        if (locationId === undefined)
+            continue;
+        positions.set(action.actorId, { actorId: action.actorId, locationId, revision, cause: { kind: 'action', sourceId: action.id } });
+    }
+    return { ...interaction, positions: interaction.positions.map(position => positions.get(position.actorId)) };
+}
+export function validateInteractionPolicy(policy, world, actors, mechanics) {
+    const interaction = initialInteraction(policy, actors);
+    if (policy === undefined)
+        return;
+    const player = actors.find(actor => actor.humanControlled);
+    const publicObject = (id) => world.domainObjects.find(object => object.id === id && dynamicObjectVisibleToActor(object, player.actorId));
+    if (interaction.locations.some(location => location.domainObjectId !== undefined && publicObject(location.domainObjectId) === undefined)
+        || policy.issue.domainObjectIds.some(id => publicObject(id) === undefined))
+        fail('interaction-policy-invalid', 'Locations and shared issues must reference public domain objects');
+    if (new Set(policy.actionLocations.map(mapping => mapping.mechanic)).size !== policy.actionLocations.length)
+        fail('interaction-policy-invalid', 'A mechanic has at most one action location mapping');
+    for (const mapping of policy.actionLocations) {
+        const definition = mechanics.find(item => item.id === mapping.mechanic);
+        if (definition === undefined)
+            fail('interaction-policy-invalid', 'Action location mapping must reference a declared mechanic');
+        if (mapping.location.kind === 'object') {
+            const name = mapping.location.intentParameter;
+            const parameter = definition.intentParameters.find(item => item.id === name);
+            if (parameter?.kind !== 'object-reference' || Object.keys(mapping.location.objectLocations).some(id => {
+                const object = publicObject(id);
+                return object === undefined || !parameter.objectKinds.includes(object.kind);
+            }))
+                fail('interaction-policy-invalid', 'Object movement mapping must match a public structured mechanic reference');
+        }
+    }
+}
+export function validateMeetingHistory(entry, interaction, actors, agencyVersion) {
+    validateMeetingAdjudications(entry.gmProposal, entry.meetings ?? [], entry.characterProposals, agencyVersion);
+    for (const meeting of entry.meetings ?? []) {
+        const policy = interaction.policy;
+        const sources = meeting.sourceProposalIds.map(id => entry.characterProposals.find(proposal => proposal.proposalId === id));
+        if (policy === null || meeting.meetingId !== `meeting-${entry.revision}` || meeting.revision !== entry.revision
+            || meeting.locationId !== policy.meetingLocationId || (policy.version === 'meetings-1' && (meeting.issue !== policy.issue.title || meeting.invitation !== undefined))
+            || new Set(meeting.participantActorIds).size !== 2 || new Set(meeting.sourceProposalIds).size !== 2
+            || sources.some((source, index) => source === undefined || source.actorId !== meeting.participantActorIds[index]
+                || !actors.some(actor => actor.actorId === source.actorId && !actor.humanControlled))
+            || !isDeepStrictEqual(meeting.audienceActorIds, [...meeting.participantActorIds, ...actors.filter(actor => actor.humanControlled).map(actor => actor.actorId)]))
+            fail('meeting-lineage-invalid', 'Meeting participants and sources must match canonical proposals');
+        if (policy.version === 'meetings-2') {
+            const recipient = sources[0], author = sources[1];
+            if (agencyVersion !== 'emergent-v1' || author.discussionInvitation == null
+                || author.discussionInvitation.recipientActorId !== recipient.actorId
+                || author.basedOnRevision !== entry.revision - 1 || recipient.basedOnRevision !== entry.revision - 1
+                || meeting.issue !== author.discussionInvitation.topic
+                || !isDeepStrictEqual(meeting.invitation, { sourceProposalId: author.proposalId, authorActorId: author.actorId, recipientActorId: recipient.actorId })
+                || meeting.turns.some(turn => turn.candidateChoiceId !== null))
+                fail('meeting-invitation-invalid', 'A discussion must match its original authored invitation');
+        }
+        const voluntary = meeting.receipts.some(receipt => receipt.instructionVersion === 3);
+        if (voluntary !== (agencyVersion === 'emergent-v1') || (voluntary && meeting.receipts.some(receipt => receipt.instructionVersion !== 3)))
+            fail('meeting-instruction-invalid', 'Meeting instructions must match the saved agency version');
+        for (const [index, turn] of meeting.turns.entries()) {
+            if (!(voluntary ? meetingTurnSchema : legacyMeetingTurnSchema).safeParse(turn).success)
+                fail('meeting-turn-invalid', 'Stored speech must match its instruction version');
+            const predecessor = meeting.turns[index - 1]?.turnId ?? null;
+            if (turn.meetingId !== meeting.meetingId || turn.turnId !== `${meeting.meetingId}-turn-${index + 1}`
+                || turn.speakerActorId !== meeting.participantActorIds[index === 1 ? 1 : 0]
+                || turn.predecessorTurnId !== predecessor)
+                fail('meeting-turn-lineage-invalid', 'Meeting transcript must follow the assigned speakers and predecessor chain');
+        }
+        for (const [index, receipt] of meeting.receipts.entries()) {
+            const turn = meeting.turns[index];
+            if (receipt.turnId !== `${meeting.meetingId}-turn-${index + 1}` || receipt.speakerActorId !== meeting.participantActorIds[index === 1 ? 1 : 0]
+                || receipt.predecessorTurnId !== (meeting.turns[index - 1]?.turnId ?? null)
+                || receipt.priorTurnsDigest !== digest(JSON.stringify(meeting.turns.slice(0, index)))
+                || (!receipt.requested && (receipt.status !== 'rejected' || receipt.outputBytes !== 0 || receipt.outputDigest !== digest('')))
+                || (receipt.status === 'declined' ? !voluntary || turn !== undefined || receipt.failureCode !== undefined || receipt.turnDigest !== null || receipt.outputBytes === 0 || receipt.outputBytes > 4096 : receipt.status === 'accepted' ? turn === undefined || receipt.failureCode !== undefined || receipt.outputBytes === 0 || receipt.outputBytes > 4096 || receipt.turnDigest !== digest(JSON.stringify(turn)) : turn !== undefined || receipt.failureCode === undefined || receipt.turnDigest !== null))
+                fail('meeting-receipt-invalid', 'Meeting receipts must match their validated ordered turns');
+        }
+        if (voluntary) {
+            validateVoluntaryMeeting(meeting);
+            continue;
+        }
+        if (meeting.status === 'accepted') {
+            const final = meeting.turns[2];
+            const choice = final === undefined ? undefined : meetingChoices(meeting.sourceProposalIds).find(choice => choice.id === final.candidateChoiceId);
+            if (meeting.turns.length !== 3 || meeting.receipts.length !== 3 || meeting.receipts.some(receipt => receipt.status !== 'accepted')
+                || choice === undefined || !isDeepStrictEqual(meeting.decision, { ...choice, finalTurnId: final.turnId }) || meeting.failureCode !== undefined)
+                fail('meeting-decision-invalid', 'Accepted meeting must contain three turns and the final ordered choice');
+        }
+        else if (meeting.decision !== null || meeting.failureCode === undefined
+            || (meeting.failureCode === 'world-consequences-rejected' ? meeting.turns.length !== 3 || meeting.receipts.length !== 3 : meeting.receipts.length !== meeting.turns.length + 1 || meeting.receipts.at(-1)?.status !== 'rejected'))
+            fail('meeting-decision-invalid', 'Rejected meeting cannot claim a decision or omit a failed receipt');
+    }
+}
+function validateVoluntaryMeeting(meeting) {
+    if (meeting.decision !== null)
+        fail('meeting-decision-invalid', 'Voluntary discussion cannot impose a decision');
+    const last = meeting.receipts.at(-1);
+    const stopped = meeting.turns.some((turn, index) => turn.endMeeting && index < meeting.receipts.length - 1)
+        || meeting.receipts.slice(0, -1).some(receipt => receipt.status !== 'accepted');
+    if (stopped || last === undefined)
+        fail('meeting-receipt-invalid', 'Discussion must stop when a participant leaves or a call fails');
+    const complete = (last.status === 'declined' && meeting.receipts.length === meeting.turns.length + 1)
+        || (last.status === 'accepted' && meeting.receipts.length === meeting.turns.length
+            && (meeting.turns.length === 3 || meeting.turns.at(-1)?.endMeeting === true));
+    if (meeting.status === 'accepted') {
+        if (!complete || meeting.failureCode !== undefined)
+            fail('meeting-decision-invalid', 'Discussion must end with voluntary speech or decline');
+    }
+    else if (meeting.failureCode === 'world-consequences-rejected' ? !complete
+        : meeting.failureCode === undefined || last.status !== 'rejected' || meeting.receipts.length !== meeting.turns.length + 1)
+        fail('meeting-decision-invalid', 'Rejected discussion must preserve its failed receipt');
+}
+export function validateMeetingAdjudications(proposal, meetings, characters, agencyVersion) {
+    if (agencyVersion === 'emergent-v1') {
+        for (const ruling of proposal.adjudications) {
+            if (ruling.meetingId !== undefined && !meetings.some(meeting => meeting.meetingId === ruling.meetingId && meeting.sourceProposalIds.includes(ruling.characterProposalId)))
+                fail('meeting-adjudication-invalid', 'A meeting reference must belong to this proposal');
+        }
+        return;
+    }
+    const accepted = meetings.filter(meeting => meeting.status === 'accepted');
+    for (const ruling of proposal.adjudications) {
+        const meeting = accepted.find(meeting => meeting.decision?.deferProposalIds.includes(ruling.characterProposalId));
+        if (meeting === undefined ? ruling.outcome === 'deferred' || ruling.meetingId !== undefined
+            : ruling.outcome !== 'deferred' || ruling.meetingId !== meeting.meetingId || ruling.actionIds.length !== 0)
+            fail('meeting-adjudication-invalid', 'Deferred adjudication must match an accepted meeting decision');
+        if (meeting !== undefined) {
+            const source = characters.find(character => character.proposalId === ruling.characterProposalId);
+            if (source === undefined || proposal.domainActions.some(action => action.sourceCharacterProposalId === source.proposalId
+                || (action.actorId === undefined && source.attemptedActions.some(attempt => action.mechanic === attempt.mechanic && isDeepStrictEqual(action.parameters.intent, attempt.parameters.intent)))))
+                fail('meeting-adjudication-invalid', 'A deferred source cannot perform an action or an actorless substitute');
+        }
+    }
+}