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

package/dist/simulation/dynamic_history.d.ts

@@ -0,0 +1,42 @@
+import type { SimulationDynamicStateV1, SimulationDynamicHistoryEntryV1, SimulationDynamicAuditEntryV1, SimulationPersistentAgentStateV1, DynamicHistoryReference, DynamicHistoryArchive } from '../plugin/simulation_contract.js';
+export declare const DYNAMIC_HISTORY_WINDOW = 16;
+export declare const DYNAMIC_HISTORY_RECORD_BYTES = 2097152;
+export type { DynamicHistoryReference, DynamicHistoryArchive };
+export type DynamicHistoryRecord = {
+    readonly version: 1;
+    readonly identity: string;
+    readonly revision: number;
+    readonly previous: DynamicHistoryReference | null;
+} & ({
+    readonly kind: 'genesis';
+    readonly state: SimulationDynamicStateV1;
+} | {
+    readonly kind: 'beat';
+    readonly entry: SimulationDynamicHistoryEntryV1;
+    readonly audit: SimulationDynamicAuditEntryV1;
+});
+/** A host-owned storage boundary. References are content checks, never validation receipts. */
+export interface DynamicHistoryStorage {
+    readonly identity: string;
+    read(reference: DynamicHistoryReference, maxBytes: number): DynamicHistoryRecord;
+    write(reference: DynamicHistoryReference, record: DynamicHistoryRecord): void;
+}
+type HistoryView = {
+    genesis: SimulationDynamicStateV1 | null;
+    history: readonly SimulationDynamicHistoryEntryV1[];
+    audit: readonly SimulationDynamicAuditEntryV1[];
+};
+export declare class DynamicHistoryError extends Error {
+    readonly code: 'history-unavailable' | 'history-invalid' | 'history-capacity';
+    constructor(code: 'history-unavailable' | 'history-invalid' | 'history-capacity', message: string);
+}
+export declare function withDynamicHistoryStorage<T>(storage: DynamicHistoryStorage, action: () => T): T;
+export declare function activeDynamicHistoryStorage(): DynamicHistoryStorage | undefined;
+export declare function dynamicHistoryReference(record: DynamicHistoryRecord): DynamicHistoryReference;
+export declare function archiveDynamicState<T extends Omit<SimulationDynamicStateV1, 'frame'>>(previous: SimulationDynamicStateV1, next: T): T;
+/** Rebuild derived storage from an original transition before parsing its referenced state. */
+export declare function stageDynamicHistoryTransition(previous: SimulationDynamicStateV1 | null, next: SimulationDynamicStateV1): void;
+export declare function readDynamicHistory(state: Pick<SimulationDynamicStateV1, 'historyArchive' | 'revision' | 'gameKind' | 'rulesVersion' | 'seed' | 'initialization'> & Partial<Pick<SimulationDynamicStateV1, 'history' | 'audit'>>): HistoryView;
+export declare function dynamicHistory(state: SimulationDynamicStateV1): readonly SimulationDynamicHistoryEntryV1[];
+export declare function dynamicMemoryHistory(state: SimulationDynamicStateV1): Readonly<Record<string, readonly SimulationPersistentAgentStateV1['memories'][number][]>> | undefined;
+export declare function dynamicBeliefEvidenceHistory(state: SimulationDynamicStateV1): Readonly<Record<string, Readonly<Record<string, readonly string[]>>>> | undefined;

package/dist/simulation/dynamic_history.js

@@ -0,0 +1,173 @@
+import { parseDynamicHistoryEntry, parseDynamicAuditEntry } from './toolkit/dynamic_state.js';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { createHash } from 'node:crypto';
+import { isDeepStrictEqual } from 'node:util';
+export const DYNAMIC_HISTORY_WINDOW = 16;
+export const DYNAMIC_HISTORY_RECORD_BYTES = 2_097_152;
+const storageScope = new AsyncLocalStorage();
+const views = new WeakMap();
+function makeImmutable(value) {
+    if (value !== null && typeof value === 'object' && !Object.isFrozen(value)) {
+        for (const item of Object.values(value))
+            makeImmutable(item);
+        Object.freeze(value);
+    }
+    return value;
+}
+export class DynamicHistoryError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'DynamicHistoryError';
+    }
+}
+export function withDynamicHistoryStorage(storage, action) {
+    return storageScope.run(storage, action);
+}
+export function activeDynamicHistoryStorage() { return storageScope.getStore(); }
+function storage() {
+    const source = storageScope.getStore();
+    if (!source)
+        throw new DynamicHistoryError('history-unavailable', 'Owned canonical history is unavailable');
+    return source;
+}
+function encode(record) {
+    const normalize = (value) => Array.isArray(value) ? value.map(normalize)
+        : value !== null && typeof value === 'object' ? Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => [key, normalize(item)])) : value;
+    const encoded = JSON.stringify(normalize(record));
+    if (Buffer.byteLength(encoded) > DYNAMIC_HISTORY_RECORD_BYTES)
+        throw new DynamicHistoryError('history-capacity', 'Canonical history record exceeds its byte bound');
+    return encoded;
+}
+export function dynamicHistoryReference(record) {
+    return { version: 1, identity: record.identity, revision: record.revision, digest: createHash('sha256').update(encode(record)).digest('hex') };
+}
+function read(reference) {
+    const source = storage();
+    if (reference.version !== 1 || reference.identity !== source.identity || !Number.isSafeInteger(reference.revision) || reference.revision < 0
+        || !/^[a-f0-9]{64}$/.test(reference.digest))
+        throw new DynamicHistoryError('history-invalid', 'Canonical history reference is invalid or foreign');
+    const record = source.read(reference, DYNAMIC_HISTORY_RECORD_BYTES);
+    if (record.version !== 1 || !isDeepStrictEqual(dynamicHistoryReference(record), reference))
+        throw new DynamicHistoryError('history-invalid', 'Canonical history content differs from its reference');
+    return record;
+}
+function write(record) {
+    const source = storage();
+    if (source.identity !== record.identity)
+        throw new DynamicHistoryError('history-invalid', 'Canonical history owner differs');
+    const reference = dynamicHistoryReference(record);
+    source.write(reference, structuredClone(record));
+    return reference;
+}
+export function archiveDynamicState(previous, next) {
+    if (!previous.historyArchive && (previous.revision !== 0 || !storageScope.getStore()))
+        return next;
+    const source = storage();
+    const genesis = previous.historyArchive?.genesis ?? write({ version: 1, identity: source.identity, revision: 0, previous: null, kind: 'genesis', state: previous });
+    const entry = next.history.at(-1);
+    const audit = next.audit.at(-1);
+    if (!entry || !audit || entry.revision !== previous.revision + 1 || audit.revision !== entry.revision)
+        throw new DynamicHistoryError('history-invalid', 'Canonical history must append its next exact beat');
+    const head = write({ version: 1, identity: source.identity, revision: entry.revision, previous: previous.historyArchive?.head ?? genesis, kind: 'beat', entry, audit });
+    return { ...next, historyArchive: { version: 1, genesis, head }, history: next.history.slice(-DYNAMIC_HISTORY_WINDOW), audit: next.audit.slice(-DYNAMIC_HISTORY_WINDOW) };
+}
+/** Rebuild derived storage from an original transition before parsing its referenced state. */
+export function stageDynamicHistoryTransition(previous, next) {
+    if (!next?.historyArchive)
+        return;
+    if (!previous)
+        throw new DynamicHistoryError('history-invalid', 'Archived history needs its original predecessor');
+    const rebuilt = archiveDynamicState(previous, next);
+    if (!isDeepStrictEqual(rebuilt.historyArchive, next.historyArchive))
+        throw new DynamicHistoryError('history-invalid', 'Canonical history rewrites its committed prefix');
+}
+export function readDynamicHistory(state) {
+    const archive = state.historyArchive;
+    if (!archive) {
+        if (!state.history || !state.audit)
+            throw new DynamicHistoryError('history-invalid', 'Unarchived history is missing');
+        return { genesis: null, history: state.history, audit: state.audit };
+    }
+    const source = storage();
+    if (archive.head.identity !== source.identity || archive.genesis.identity !== source.identity)
+        throw new DynamicHistoryError('history-invalid', 'Canonical history reference is invalid or foreign');
+    if (!Number.isSafeInteger(state.revision) || state.revision < 0 || archive.version !== 1 || archive.genesis.revision !== 0 || archive.head.revision < state.revision)
+        throw new DynamicHistoryError('history-invalid', 'Canonical history range is invalid');
+    const prefix = (value) => state.revision === archive.head.revision ? value
+        : { genesis: value.genesis, history: Object.freeze(value.history.slice(0, state.revision)), audit: Object.freeze(value.audit.slice(0, state.revision)) };
+    const key = JSON.stringify([archive, state.gameKind, state.rulesVersion, state.seed, state.initialization]);
+    const prior = views.get(source)?.find(item => item.key === key);
+    if (prior)
+        return prefix(prior.value);
+    // Keep references while walking backward; record bodies are bounded individual reads.
+    const refs = [];
+    let cursor = archive.head;
+    while (cursor.revision > 0) {
+        const record = read(cursor);
+        if (record.kind !== 'beat' || !record.previous || record.previous.revision !== record.revision - 1
+            || record.entry.revision !== record.revision || record.audit.revision !== record.revision)
+            throw new DynamicHistoryError('history-invalid', 'Canonical history is incomplete or out of order');
+        refs.push(cursor);
+        cursor = record.previous;
+    }
+    if (!isDeepStrictEqual(cursor, archive.genesis))
+        throw new DynamicHistoryError('history-invalid', 'Canonical history has a different genesis');
+    const first = read(cursor);
+    if (first.kind !== 'genesis' || first.previous !== null || first.state.revision !== 0 || first.state.historyArchive !== undefined
+        || first.state.gameKind !== state.gameKind || first.state.rulesVersion !== state.rulesVersion || first.state.seed !== state.seed
+        || !isDeepStrictEqual(first.state.initialization, state.initialization))
+        throw new DynamicHistoryError('history-invalid', 'Canonical history genesis identity is invalid');
+    const history = [];
+    const audit = [];
+    for (const reference of refs.reverse()) {
+        const record = read(reference);
+        if (record.kind !== 'beat')
+            throw new DynamicHistoryError('history-invalid', 'Canonical history beat is unavailable');
+        history.push(parseDynamicHistoryEntry(record.entry));
+        audit.push(parseDynamicAuditEntry(record.audit));
+    }
+    const result = makeImmutable({ genesis: first.state, history, audit });
+    // Two immutable decoded views, at most four MiB each, per owned operation.
+    if (Buffer.byteLength(JSON.stringify(result)) <= 4_194_304) {
+        const retained = views.get(source) ?? [];
+        views.set(source, [...retained.slice(-1), { key, value: result }]);
+    }
+    return prefix(result);
+}
+export function dynamicHistory(state) { return readDynamicHistory(state).history; }
+export function dynamicMemoryHistory(state) {
+    if (!state.historyArchive)
+        return undefined;
+    const source = readDynamicHistory(state);
+    const memories = Object.fromEntries(source.genesis.agents.map(actor => [actor.actorId, [...actor.memories]]));
+    for (const entry of source.history)
+        for (const update of entry.gmProposal.agentUpdates)
+            memories[update.actorId]?.push(...update.memoriesToAppend);
+    return memories;
+}
+export function dynamicBeliefEvidenceHistory(state) {
+    if (!state.historyArchive)
+        return undefined;
+    const source = readDynamicHistory(state);
+    const actors = new Map(source.genesis.agents.map(actor => [actor.actorId,
+        new Map(actor.beliefs.map(belief => [belief.id, new Set(belief.evidenceEventIds)]))]));
+    for (const entry of source.history)
+        for (const update of entry.gmProposal.agentUpdates) {
+            const beliefs = actors.get(update.actorId);
+            if (!beliefs)
+                throw new DynamicHistoryError('history-invalid', 'Archived belief actor is unavailable');
+            for (const belief of update.beliefsToAppend)
+                beliefs.set(belief.id, new Set(belief.evidenceEventIds));
+            for (const updateBelief of update.beliefUpdates) {
+                const evidence = beliefs.get(updateBelief.beliefId);
+                if (!evidence)
+                    throw new DynamicHistoryError('history-invalid', 'Archived belief is unavailable');
+                for (const eventId of updateBelief.evidenceEventIds)
+                    evidence.add(eventId);
+            }
+        }
+    return Object.fromEntries([...actors].map(([actorId, beliefs]) => [actorId,
+        Object.fromEntries([...beliefs].map(([beliefId, evidence]) => [beliefId, [...evidence]]))]));
+}

package/dist/simulation/engines/swarm/pane_manager.js

@@ -8,6 +8,7 @@ import { join, dirname } from 'path';
 import { existsSync, mkdirSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { randomUUID } from 'crypto';
+import { resolveOwnedCliLaunch } from '../../../desktop/cli_launch.js';
 import { DEFAULT_FREE_SIM_CONFIG } from '../../types.js';
 import { extractMeetingUtterance, isZtcRequestBusEnvelope } from './message_envelope.js';
 import { clearBusTransport, setBusTransport } from '../../../agent/tools/bus_message.js';
@@ -427,7 +428,7 @@ export async function setupRealPanes(state, logs, infra, onProgress, agentsOverr
         }
         // 5. Start PaneRelayServer so children can manage sub-panes
         infra.relayServer = new PaneRelayServer(infra.tuiProcess, simEnv.ZTC_PANE_RELAY);
-        infra.relayServer.start();
+        await infra.relayServer.start();
         // 6. Wire bus transport (same pattern as cli_ratatui.ts:419-431)
         const server = infra.mirrorServer;
         setBusTransport({
@@ -487,15 +488,15 @@ export async function setupRealPanes(state, logs, infra, onProgress, agentsOverr
             }
             else {
                 const paneCreated = waitForPaneCreated(infra.tuiProcess, paneTitle, PANE_CREATION_TIMEOUT_MS, stopSignal);
+                const childArgs = ['--headless', '--pane', '--session-id', sessionId,
+                    '--model', state.config.model, '--provider', state.config.provider];
+                const ownedLaunch = resolveOwnedCliLaunch(childArgs);
                 const sent = infra.tuiProcess.send({
                     type: 'create_pane',
-                    command: process.execPath,
+                    command: ownedLaunch?.command ?? process.execPath,
                     // --headless --pane: child enters RatatuiApp headless-mirror path with bus
                     // connectivity via MirrorClient (ZTC_MIRROR_PORT).
-                    args: [
-                        ztcEntry, '--headless', '--pane', '--session-id', sessionId,
-                        '--model', state.config.model, '--provider', state.config.provider,
-                    ],
+                    args: ownedLaunch?.args ?? [ztcEntry, ...childArgs],
                     cwd: state.config.outputDir,
                     title: paneTitle,
                     pane_type: 'ztc',

package/dist/simulation/inference.d.ts

@@ -3,10 +3,12 @@ export interface ResolvedSimulationInference {
     provider: string;
     model: string;
     codexEffort?: CodexReasoningEffort;
+    codexFastMode?: boolean;
     apiKey?: string;
     baseUrl?: string;
     embeddingApiKey?: string;
     embeddingBaseUrl?: string;
     embeddingModel?: string;
+    codexAuthFilePath?: string;
 }
-export declare function resolveSimulationInference(): ResolvedSimulationInference;
+export declare function resolveSimulationInference(explicitRoute?: Pick<ResolvedSimulationInference, 'provider' | 'model' | 'codexEffort' | 'codexFastMode'>): ResolvedSimulationInference;

package/dist/simulation/inference.js

@@ -13,7 +13,25 @@ function resolveApiKeyFromConfig(provider, explicitApiKey, envVarName) {
     }
     return configStore.getApiKey(provider) || process.env.OPENAI_API_KEY;
 }
-export function resolveSimulationInference() {
+export function resolveSimulationInference(explicitRoute) {
+    if (explicitRoute) {
+        const backendConfig = configStore.resolveLLMBackendConfig({
+            provider: explicitRoute.provider,
+            model: explicitRoute.model,
+        });
+        const apiKey = resolveApiKeyFromConfig(explicitRoute.provider);
+        const baseUrl = explicitRoute.provider === 'openai_compatible'
+            ? configStore.getOpenAICompatibleBaseUrl() || undefined
+            : undefined;
+        return {
+            ...explicitRoute,
+            apiKey,
+            baseUrl,
+            embeddingApiKey: apiKey,
+            embeddingBaseUrl: baseUrl,
+            codexAuthFilePath: backendConfig.codexAuthFilePath,
+        };
+    }
     const envProvider = process.env.ZTC_SIM_PROVIDER;
     const envModel = process.env.ZTC_SIM_MODEL;
     if (envProvider && envModel) {

package/dist/simulation/intervention_generation.d.ts

@@ -0,0 +1,27 @@
+import type { SimulationPersistentAgentStateV1 } from '../plugin/simulation_contract.js';
+import type { ActorInterventionContext } from '../plugin/simulation_interventions.js';
+interface Schema {
+    [key: string]: unknown;
+    properties?: Record<string, Schema>;
+    required?: string[];
+    anyOf?: Schema[];
+    oneOf?: Schema[];
+    items?: Schema;
+    enum?: readonly unknown[];
+}
+/** Bind the explicitly selected receipt to its typed output; acceptance remains canonical. */
+export declare function interventionActorResponseSchema(context: ActorInterventionContext, updateSchema: Schema, actor: SimulationPersistentAgentStateV1, causeIds: readonly string[], agencyVersion?: 'emergent-v1', receiptVersion?: 1 | 2 | 3): Schema;
+/** Offer one optional slot per already-permitted relationship target. */
+export declare function keyedActorResponseSchema(schema: Schema): Schema;
+export type DynamicActorInstructionVersion = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11;
+export interface ActorReceiptCauseBinding {
+    readonly version: 3;
+    readonly actorId: string;
+    readonly revision: number;
+    readonly inputIds: readonly string[];
+    readonly sourceActionIds: readonly string[];
+    readonly sourceAdjudicationProposalIds?: readonly string[];
+}
+/** Move explicit wire witnesses into their canonical update without changing authored values. */
+export declare function normalizeDynamicActorResponse(value: Record<string, unknown>, version: DynamicActorInstructionVersion, binding?: ActorReceiptCauseBinding): Record<string, unknown>;
+export {};

package/dist/simulation/intervention_generation.js

@@ -0,0 +1,246 @@
+import { intentSchema } from './toolkit/dynamic_state.js';
+import { isDeepStrictEqual } from 'node:util';
+import { interventionResolutionSchema, SimulationInputError } from './session_input_validation.js';
+/** Bind the explicitly selected receipt to its typed output; acceptance remains canonical. */
+export function interventionActorResponseSchema(context, updateSchema, actor, causeIds, agencyVersion, receiptVersion = 1) {
+    const properties = updateSchema.properties;
+    const goals = properties.goalsToAppend.items.properties.id.enum;
+    const receipts = interventionResolutionSchema(context, updateSchema, actor.goals.filter(goal => goal.status === 'active').map(goal => goal.id), causeIds, agencyVersion);
+    if (agencyVersion === 'emergent-v1' && (receiptVersion === 2 || receiptVersion === 3)) {
+        const receipt = receipts.items.anyOf[0];
+        const kinds = receipt.properties.change.anyOf;
+        const changes = kinds.flatMap(option => {
+            const kind = option.properties.kind.const;
+            const fields = kind === 'intent' ? [['nextIntent', properties.nextIntent]]
+                : kind === 'belief' ? [['beliefUpdate', properties.beliefUpdates.items], ['beliefToAppend', properties.beliefsToAppend.items]]
+                    : [['relationshipDelta', properties.relationshipDeltas.items]];
+            return fields.map(([field, schema]) => ({ ...option, required: [...option.required, field],
+                properties: { ...option.properties, [field]: schema } }));
+        });
+        const linked = { ...receipts, items: { anyOf: [
+                    { ...receipt, properties: { ...receipt.properties, change: { anyOf: changes } } },
+                    receipts.items.anyOf[1],
+                ] } };
+        if (receiptVersion === 3) {
+            linked.items.anyOf = linked.items.anyOf.map(item => {
+                const { causeIds: _causeIds, ...properties } = item.properties;
+                return { ...item, required: item.required.filter(field => field !== 'causeIds'), properties };
+            });
+        }
+        return { type: 'object', additionalProperties: false, required: ['consequence'], properties: { consequence: {
+                    type: 'object', additionalProperties: false, required: ['agentUpdate', 'inputResolutions', 'receiptVersion'], properties: {
+                        agentUpdate: { anyOf: [updateSchema, { type: 'null' }] }, inputResolutions: linked, receiptVersion: { const: receiptVersion, type: 'integer' },
+                    },
+                } }, 'x-ztc-compact-keys': true };
+    }
+    if (agencyVersion === 'emergent-v1')
+        return {
+            type: 'object', additionalProperties: false, required: ['consequence'], properties: { consequence: {
+                    type: 'object', additionalProperties: false, required: ['agentUpdate', 'inputResolutions'], properties: {
+                        agentUpdate: { anyOf: [updateSchema, { type: 'null' }] }, inputResolutions: receipts,
+                    },
+                } }, 'x-ztc-compact-keys': true,
+        };
+    const branches = [];
+    const intentsForGoal = (goalId) => properties.nextIntent.anyOf.flatMap(option => option.oneOf ?? []).filter(intent => {
+        const goal = intent.properties.goalId;
+        return goal.const === goalId || goal.enum?.includes(goalId);
+    }).map(intent => ({ ...intent, properties: { ...intent.properties, goalId: { const: goalId } } }));
+    const existingIntents = actor.goals.filter(goal => goal.status === 'active').flatMap(goal => intentsForGoal(goal.id));
+    const existingNextIntent = { anyOf: [{ type: 'null' }, ...(existingIntents.length ? [{ oneOf: existingIntents }] : [])] };
+    const branch = (kind, recordId, fields) => {
+        const update = { ...updateSchema, required: [...new Set([...updateSchema.required, ...Object.keys(fields)])], properties: { ...properties, nextIntent: existingNextIntent, ...fields } };
+        branches.push({ type: 'object', additionalProperties: false, required: ['agentUpdate', 'inputResolutions'], properties: {
+                agentUpdate: update,
+                inputResolutions: { ...receipts, items: { ...receipts.items, properties: { ...receipts.items.properties,
+                            change: { type: 'object', additionalProperties: false, required: ['kind', 'recordId'], properties: { kind: { const: kind }, recordId: { const: recordId } } }, } } },
+            } });
+    };
+    const selectedArray = (name, idField, id, extra = {}) => ({
+        ...properties[name], minItems: 1, maxItems: 1, items: { ...properties[name].items, properties: { ...properties[name].items.properties, [idField]: { const: id }, ...extra } },
+    });
+    for (const goalId of [...actor.goals.filter(goal => goal.status === 'active').map(goal => goal.id), ...goals]) {
+        const intents = intentsForGoal(goalId);
+        if (intents.length > 0)
+            branch('intent', goalId, {
+                nextIntent: { anyOf: intents },
+                ...(goals.includes(goalId) ? { goalsToAppend: selectedArray('goalsToAppend', 'id', goalId) } : {}),
+            });
+    }
+    for (const belief of actor.beliefs) {
+        const confidence = [
+            ...(belief.confidence > 0 ? [{ type: 'integer', minimum: 0, maximum: belief.confidence - 1 }] : []),
+            ...(belief.confidence < 100 ? [{ type: 'integer', minimum: belief.confidence + 1, maximum: 100 }] : []),
+        ];
+        branch('belief', belief.id, { beliefUpdates: selectedArray('beliefUpdates', 'beliefId', belief.id, { confidence: { anyOf: confidence } }) });
+    }
+    for (const id of properties.beliefsToAppend.items.properties.id.enum) {
+        branch('belief', id, { beliefsToAppend: selectedArray('beliefsToAppend', 'id', id) });
+    }
+    for (const id of properties.relationshipDeltas.items.properties.targetActorId.enum) {
+        branch('relationship', id, { relationshipDeltas: selectedArray('relationshipDeltas', 'targetActorId', id) });
+    }
+    return { type: 'object', additionalProperties: false, required: ['consequence'], properties: { consequence: { anyOf: branches } }, 'x-ztc-compact-keys': true };
+}
+/** Offer one optional slot per already-permitted relationship target. */
+export function keyedActorResponseSchema(schema) {
+    const result = structuredClone(schema);
+    const envelope = result.properties.consequence ?? result;
+    const update = envelope.properties.agentUpdate.anyOf[0];
+    const entries = update.properties.relationshipDeltas.items.anyOf ?? [];
+    update.properties.relationshipDeltas = { type: 'object', additionalProperties: false, required: [],
+        properties: Object.fromEntries(entries.map(entry => [entry.properties.targetActorId.const, entry])),
+    };
+    result['x-ztc-keyed-relationships'] = 2;
+    return result;
+}
+/** Move explicit wire witnesses into their canonical update without changing authored values. */
+export function normalizeDynamicActorResponse(value, version, binding) {
+    function invalid() { throw new SimulationInputError('input_resolution_invalid', 'Actor receipt wire version or typed witness is invalid'); }
+    if (![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11].includes(version))
+        invalid();
+    const object = (item) => item !== null && typeof item === 'object' && !Array.isArray(item);
+    const envelope = structuredClone(value);
+    if (binding !== undefined) {
+        const consequence = envelope.consequence;
+        if (binding.version !== 3 || ![8, 9, 11].includes(version) || !object(consequence)
+            || consequence.receiptVersion !== 3 || !Array.isArray(consequence.inputResolutions)
+            || binding.inputIds.length === 0 || new Set(binding.inputIds).size !== binding.inputIds.length)
+            invalid();
+        const sources = [...binding.sourceActionIds, ...(binding.sourceAdjudicationProposalIds ?? [])];
+        if (new Set(sources).size !== sources.length || sources.some(id => binding.inputIds.includes(id)))
+            invalid();
+        const results = consequence.inputResolutions;
+        if (results.length !== binding.inputIds.length || new Set(results.map(result => object(result) ? result.inputId : null)).size !== binding.inputIds.length)
+            invalid();
+        const sameIds = (actual, expected) => Array.isArray(actual)
+            && actual.every(id => typeof id === 'string') && isDeepStrictEqual([...actual].sort(), [...expected].sort());
+        const update = consequence.agentUpdate;
+        if (update !== null && (!object(update) || update.actorId !== binding.actorId
+            || (update.sourceActionIds !== undefined && !sameIds(update.sourceActionIds, binding.sourceActionIds))
+            || (update.sourceAdjudicationProposalIds !== undefined && !sameIds(update.sourceAdjudicationProposalIds, binding.sourceAdjudicationProposalIds ?? []))))
+            invalid();
+        for (const result of results) {
+            if (!object(result) || result.actorId !== binding.actorId || result.revision !== binding.revision
+                || typeof result.inputId !== 'string' || !binding.inputIds.includes(result.inputId) || Object.hasOwn(result, 'causeIds'))
+                invalid();
+            result.causeIds = result.change === null ? [result.inputId] : [result.inputId, ...sources];
+        }
+        consequence.receiptVersion = 2;
+    }
+    if (version === 10 || version === 11) {
+        const body = version === 11 ? envelope.consequence : envelope;
+        if (!object(body))
+            invalid();
+        const update = body.agentUpdate;
+        if (object(update) && Object.hasOwn(update, 'relationshipDeltas')) {
+            const slots = update.relationshipDeltas;
+            if (!object(slots))
+                invalid();
+            update.relationshipDeltas = Object.entries(slots).flatMap(([targetActorId, delta]) => {
+                if (delta === null)
+                    return [];
+                if (!object(delta) || delta.targetActorId !== targetActorId)
+                    invalid();
+                return [delta];
+            });
+        }
+        version = version === 10 ? 7 : 9;
+    }
+    if (version !== 6 && version !== 8 && version !== 9) {
+        if (Object.hasOwn(envelope, 'receiptVersion') || (object(envelope.consequence) && Object.hasOwn(envelope.consequence, 'receiptVersion')))
+            invalid();
+        return envelope;
+    }
+    const consequence = envelope.consequence;
+    if (Object.keys(envelope).length !== 1 || !object(consequence) || consequence.receiptVersion !== 2
+        || Object.keys(consequence).sort().join(',') !== 'agentUpdate,inputResolutions,receiptVersion'
+        || !Array.isArray(consequence.inputResolutions) || (consequence.agentUpdate !== null && !object(consequence.agentUpdate)))
+        invalid();
+    let update = consequence.agentUpdate;
+    const pending = new Map();
+    for (const result of consequence.inputResolutions) {
+        if (!object(result))
+            invalid();
+        const change = result.change;
+        if (change === null)
+            continue;
+        if (!object(change) || typeof result.actorId !== 'string')
+            invalid();
+        const fields = change.kind === 'intent' ? ['nextIntent'] : change.kind === 'belief' ? ['beliefUpdate', 'beliefToAppend']
+            : change.kind === 'relationship' ? ['relationshipDelta'] : invalid();
+        const present = fields.filter(field => Object.hasOwn(change, field));
+        if (present.length !== 1 || Object.keys(change).length !== 3 || typeof change.recordId !== 'string')
+            invalid();
+        update ??= { actorId: result.actorId };
+        if (update.actorId !== result.actorId)
+            invalid();
+        const field = present[0];
+        const authored = change[field];
+        if (field === 'nextIntent') {
+            if (authored !== null && !object(authored))
+                invalid();
+            if (version === 9) {
+                if (authored !== null && !intentSchema.safeParse(authored).success)
+                    invalid();
+                if (Object.hasOwn(update, field)) {
+                    const canonical = update[field];
+                    if (canonical !== null && !intentSchema.safeParse(canonical).success)
+                        invalid();
+                    const actionFields = (intent) => intent === null ? null
+                        : Object.fromEntries(Object.entries(intent).filter(([key]) => key !== 'summary'));
+                    if (!isDeepStrictEqual(actionFields(canonical), actionFields(authored)))
+                        invalid();
+                }
+                else
+                    update[field] = authored;
+            }
+            else {
+                if (Object.hasOwn(update, field) && !isDeepStrictEqual(update[field], authored))
+                    invalid();
+                update[field] = authored;
+            }
+        }
+        else {
+            if (!object(authored))
+                invalid();
+            const [target, idField] = field === 'beliefUpdate' ? ['beliefUpdates', 'beliefId']
+                : field === 'beliefToAppend' ? ['beliefsToAppend', 'id'] : ['relationshipDeltas', 'targetActorId'];
+            const id = authored[idField];
+            if (typeof id !== 'string' || id !== change.recordId)
+                invalid();
+            const values = pending.get(target) ?? new Map();
+            const prior = values.get(id);
+            if (prior !== undefined && !isDeepStrictEqual(prior, authored))
+                invalid();
+            values.set(id, authored);
+            pending.set(target, values);
+        }
+        result.change = { kind: change.kind, recordId: change.recordId };
+    }
+    for (const [target, values] of pending) {
+        const idField = target === 'beliefUpdates' ? 'beliefId' : target === 'beliefsToAppend' ? 'id' : 'targetActorId';
+        const prior = update[target];
+        if (prior !== undefined && !Array.isArray(prior))
+            invalid();
+        const merged = (prior ?? []);
+        for (const [id, authored] of [...values].sort(([left], [right]) => left.localeCompare(right))) {
+            const matching = merged.filter(item => object(item) && item[idField] === id);
+            if (matching.length > 1 || (matching.length === 1 && !isDeepStrictEqual(matching[0], authored)))
+                invalid();
+            if (matching.length === 0)
+                merged.push(authored);
+        }
+        update[target] = merged;
+    }
+    if (update !== null) {
+        const existing = update.beliefUpdates;
+        const appended = update.beliefsToAppend;
+        if (Array.isArray(existing) && Array.isArray(appended) && existing.some(item => object(item)
+            && appended.some(other => object(other) && item.beliefId === other.id)))
+            invalid();
+    }
+    consequence.agentUpdate = update;
+    delete consequence.receiptVersion;
+    return envelope;
+}

package/dist/simulation/intervention_material.d.ts

@@ -0,0 +1,4 @@
+import type { SimulationDynamicHistoryEntryV1, SimulationPersistentAgentStateV1 } from '../plugin/simulation_contract.js';
+import type { SimulationInterventionResolutionV1 } from '../plugin/simulation_interventions.js';
+/** Check the claimed change or a permitted no-change decision; canonical transition validation owns the world. */
+export declare function hasMaterialInterventionChange(before: SimulationPersistentAgentStateV1, entry: SimulationDynamicHistoryEntryV1, result: SimulationInterventionResolutionV1, after?: SimulationPersistentAgentStateV1, agencyVersion?: 'emergent-v1', beliefEvidenceHistory?: Readonly<Record<string, readonly string[]>>): boolean;