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

package/dist/simulation/living/runtime.js

@@ -0,0 +1,3020 @@
+import { assertLivingModelCall, withContextLookup, MODEL_VIEW_NOTE, contextSelectionInput } from './model-input.js';
+import { BOUNDED_IDENTIFIERS_ENGINE, generatedId } from './identifiers.js';
+import { createHash } from 'node:crypto';
+import { isDeepStrictEqual } from 'node:util';
+import { z } from 'zod';
+import { fitSpeechInput, speechSetting, modelContextPeople, CHARACTER_MESSAGE_SYSTEM, CHARACTER_PLAN_SYSTEM, CHARACTER_REACTION_SYSTEM, GAME_MASTER_SYSTEM, NARRATOR_EPILOGUE_SYSTEM, SPEECH_IMPACT_SYSTEM, characterMessageReplyInput, characterPlanInput, characterReactionInput, clockLabel, epilogueInput, gameMasterAttemptInput, gameMasterWorldInput, earlierTimes, personLabel, } from './context.js';
+import { createLivingState } from './definition.js';
+import { SIGNAL_NOTICES, SIGNAL_SENSES, LIVING_INFERENCE_LIMITS, epilogueResponseSchema, messageReplyResponseSchema, scopedPlanResponseSchema, scopedAttemptResponseSchema, scopedReactionResponseSchema, scopedSpeechImpactResponseSchema, } from './inference.js';
+import { blockedByGate, gatesAgainst, heldHere, importanceFloorForEffects, normViolationsFor, signalNotice, predictionReady } from './mechanics.js';
+import { kindRequestSchema } from './open-world.js';
+import { observedSummary } from './projection.js';
+import { applyLivingEvent, arrivalFor, clockTargetAt, countNote, countResult, nearbyFor, peopleAt, travelPath, unansweredSince, votingShut, witnessesFor, TRAVEL_MINUTES_PER_HOP } from './reduce.js';
+import { AVERTED_ENGINE, isNight, REMINDER_ENGINE, REMINDER_MINUTES, LONG_DAY_MINUTES, LivingWorldError, MAX_CLOCK_RATE, MAX_LINE, MAX_TEXT, MAX_ROLE, FULL_SCHEDULE_INTENT_ENGINE, MAX_SPOKEN, PROMISE_IMPORTANCE, PROMISE_LEAD_MINUTES, STALL_MINUTES, THING_MEMORY_ENGINE, THINGS_SEEN_ENGINE, WALK_OFF_ENGINE, effectSchema, endingSchema, } from './types.js';
+export const MAX_DUE_ITEMS_PER_STEP = 2;
+export const MAX_DUE_ERRANDS_PER_STEP = 4;
+export const MAX_REACTORS = 2;
+// Every player command runs within this many model calls. The player's own attempt or
+// words come first; reactions, replies and due plans are skipped once the budget is spent.
+export const MAX_MODEL_CALLS_PER_COMMAND = 6;
+export const MAX_NONPLAYER_MINUTES_PER_COMMAND = 20;
+// From this importance up, an act is a shock: every witness decides what to do about it.
+export const SHOCK_IMPORTANCE = 7;
+const ROUTINE_PLAN_IMPORTANCE = 3;
+export const SHOCK_PLAN_DELAY_MINUTES = 5;
+export const OTHERS_MAX_MINUTES = 10;
+// In a live world an act longer than this only begins at once; its end is ruled when its time has passed.
+export const LONG_ACT_MINUTES = 10;
+// A deadline the Game Master cannot rule happens this long after its time, from its data alone.
+export const DEADLINE_GRACE_MINUTES = 15;
+// Failures that mean others' answers must wait, not that the player's act did not happen.
+const LATER_CODES = new Set(['inference-unavailable', 'inference-invalid', 'run-paused']);
+export const ERRAND_DELAY_MINUTES = 3;
+export const SPEECH_MINUTES = 1;
+export const MESSAGE_MINUTES = 1;
+export const MESSAGE_REPLY_DELAY_MINUTES = 10;
+export const IDLE_WAIT_MINUTES = 60;
+export const OVERDUE_WAIT_MINUTES = 15;
+export const PLAYER_MAX_TEXT_BYTES = 2000;
+// A person whose decision names no next activity keeps at it this long before deciding again.
+export const DEFAULT_ACTIVITY_MINUTES = 30;
+const MIN_SEEN_LENGTH = 3;
+// A ruling that returns to a changed scene is ruled again at most this many times.
+const MAX_STALE_RULINGS = 2;
+const sha256 = (value) => createHash('sha256').update(JSON.stringify(value)).digest('hex');
+function characterInputRefs(state, call, actorId, causeSeq = null) {
+    if (call.role !== 'character' || actorId === null)
+        return [];
+    const person = state.people[actorId];
+    if (!person)
+        return [];
+    const memories = new Map(person.memories.map(memory => [memory.id, memory]));
+    const refs = [];
+    for (const field of ['memories', 'recentlySeen', 'landmarks', 'pressing']) {
+        const items = call.input[field];
+        if (!Array.isArray(items))
+            continue;
+        items.forEach((value, index) => {
+            if (value === null || typeof value !== 'object' || Array.isArray(value))
+                return;
+            const id = value.id;
+            if (typeof id !== 'string')
+                return;
+            const memory = memories.get(id);
+            if (!memory)
+                return;
+            refs.push({ path: `/${field}/${index}`, inputSha256: sha256(value), kind: field === 'pressing' ? 'pressing' : 'memory', id,
+                evidenceEventSeq: memory.evidence?.eventSeq ?? memory.eventSeq });
+        });
+    }
+    const summaries = call.input.summaries;
+    if (Array.isArray(summaries))
+        summaries.forEach((value, index) => {
+            if (value === null || typeof value !== 'object' || Array.isArray(value))
+                return;
+            const id = value.id;
+            if (typeof id !== 'string')
+                return;
+            const summary = person.summaries?.find(item => item.id === id && item.personId === actorId);
+            if (!summary)
+                return;
+            refs.push({ path: `/summaries/${index}`, inputSha256: sha256(value), kind: 'summary', id,
+                evidenceEventSeq: Math.max(...summary.sourceEventSeqs) });
+        });
+    const requests = call.input.requests;
+    if (Array.isArray(requests))
+        requests.forEach((value, index) => {
+            if (value === null || typeof value !== 'object' || Array.isArray(value))
+                return;
+            const id = value.id;
+            if (typeof id !== 'string')
+                return;
+            const request = state.requests.find(item => item.id === id && item.knownTo.includes(actorId));
+            if (!request)
+                return;
+            refs.push({ path: `/requests/${index}`, inputSha256: sha256(value), kind: 'request', id,
+                evidenceEventSeq: request.openedSeq });
+        });
+    const beliefs = call.input.beliefs;
+    if (Array.isArray(beliefs))
+        beliefs.forEach((value, index) => {
+            if (value === null || typeof value !== 'object' || Array.isArray(value))
+                return;
+            const id = value.id;
+            if (typeof id !== 'string')
+                return;
+            const belief = person.beliefs.find(item => item.id === id);
+            if (!belief)
+                return;
+            refs.push({ path: `/beliefs/${index}`, inputSha256: sha256(value), kind: 'belief', id,
+                evidenceEventSeq: belief.source.eventSeq });
+        });
+    const seen = new Set(refs.map(ref => ref.path));
+    const add = (path, value) => {
+        if (seen.has(path))
+            return;
+        const rootEnd = path.indexOf('/', 1);
+        const root = path.slice(1, rootEnd < 0 ? undefined : rootEnd);
+        const record = value !== null && typeof value === 'object' && !Array.isArray(value)
+            ? value : null;
+        const rootEnd0 = path.indexOf('/', 1);
+        const id = typeof record?.id === 'string' && path.slice(1, rootEnd0 < 0 ? undefined : rootEnd0) !== 'goals' ? record.id : actorId;
+        let kind = 'self';
+        let evidenceEventSeq = 0;
+        if (root === 'scene' || root === 'exits' || root === 'playerHere')
+            kind = 'present';
+        else if (root === 'directory')
+            kind = path.startsWith('/directory/people/') ? 'known-person'
+                : path.startsWith('/directory/places/') ? 'known-place' : 'known-directory';
+        else if (root === 'playerId' || root === 'playerName' || root === 'playerPronouns')
+            kind = 'known-person';
+        else if (root === 'relationships')
+            kind = 'relationship';
+        else if (root === 'pressing')
+            kind = 'pressing';
+        else if (root === 'summaries')
+            kind = 'summary';
+        else if (root === 'commitments')
+            kind = 'commitment';
+        else if (root === 'promisedToMe')
+            kind = 'promise';
+        else if (root === 'stances')
+            kind = 'stance';
+        else if (root === 'previousErrors')
+            kind = 'feedback';
+        else if (root === 'happened' || root === 'message') {
+            kind = 'event';
+            evidenceEventSeq = causeSeq ?? 0;
+        }
+        else if (root === 'duePlan')
+            kind = 'schedule';
+        const refId = root === 'scene' || root === 'exits' ? record?.id ?? person.placeId
+            : root === 'playerId' || root === 'playerName' || root === 'playerPronouns' || root === 'playerHere' ? state.playerId
+                : root === 'directory' && path.startsWith('/directory/places/') ? record?.id
+                    : root === 'happened' || root === 'message' ? String(evidenceEventSeq)
+                        : id;
+        if (typeof refId !== 'string')
+            return;
+        let sourceId = refId;
+        if (kind === 'schedule' && record !== null && typeof record.intent === 'string') {
+            const due = state.schedule.find(item => item.kind === 'plan' && item.personId === actorId && item.intent === record.intent);
+            if (due) {
+                sourceId = due.id;
+                evidenceEventSeq = due.sourceSeq;
+            }
+        }
+        if (kind === 'commitment' || kind === 'promise') {
+            const made = kind === 'commitment' ? person.commitments.find(commitment => commitment.id === refId)
+                : Object.values(state.people).flatMap(other => other.commitments).find(commitment => commitment.id === refId && commitment.toId === actorId);
+            const source = state.events.find(event => event.effects.some(effect => effect.kind === 'commitment' && effect.commitmentId === refId));
+            evidenceEventSeq = made?.madeSeq ?? source?.seq ?? 0;
+        }
+        if (kind === 'stance' && typeof record?.sourceSeq === 'number')
+            evidenceEventSeq = record.sourceSeq;
+        if (kind === 'relationship') {
+            const source = [...state.events].reverse().find(event => event.effects.some(effect => effect.kind === 'relationship'
+                && effect.personId === actorId && effect.targetId === refId));
+            evidenceEventSeq = person.relationships[refId]?.changedSeq ?? source?.seq ?? 0;
+        }
+        if (kind === 'known-place' && refId !== person.placeId
+            && !state.places[person.placeId]?.connections.includes(refId)) {
+            evidenceEventSeq = person.memories.find(memory => memory.placeId === refId && memory.evidence)?.evidence?.eventSeq ?? 0;
+        }
+        if (kind === 'known-person' && state.people[refId]?.placeId !== person.placeId) {
+            evidenceEventSeq = person.memories.find(memory => memory.participantIds.includes(refId) && memory.evidence)?.evidence?.eventSeq
+                ?? person.beliefs.find(belief => belief.source.personId === refId)?.source.eventSeq ?? 0;
+        }
+        refs.push({ path, inputSha256: sha256(value), kind, id: sourceId, evidenceEventSeq });
+        seen.add(path);
+    };
+    const visit = (value, path) => {
+        if (Array.isArray(value)) {
+            value.forEach((item, index) => visit(item, `${path}/${index}`));
+            return;
+        }
+        add(path, value);
+        if (value !== null && typeof value === 'object')
+            for (const [key, child] of Object.entries(value)) {
+                if (Array.isArray(child))
+                    visit(child, `${path}/${key.replaceAll('~', '~0').replaceAll('/', '~1')}`);
+            }
+    };
+    for (const [key, value] of Object.entries(call.input))
+        if (key !== 'phase' && key !== 'clock')
+            visit(value, `/${key.replaceAll('~', '~0').replaceAll('/', '~1')}`);
+    return refs;
+}
+const clampInt = (value, min, max, fallback) => typeof value === 'number' && Number.isInteger(value) ? Math.max(min, Math.min(max, value)) : fallback;
+export function cleanMood(value, fallback) {
+    const mood = typeof value === 'string' ? value.trim().slice(0, 40) : '';
+    return mood || fallback;
+}
+// One command runs inside one session: the state advances as events commit, and the
+// audit keeps a digest-only receipt of every model call.
+class Session {
+    cell;
+    inference;
+    takenEntityIds;
+    events = [];
+    audit = [];
+    calls = 0;
+    nonPlayerMinutes = 0;
+    // How many acts made in answer to another act are being ruled now.
+    answeringActs = 0;
+    constructor(cell, inference, takenEntityIds = async () => new Set()) {
+        this.cell = cell;
+        this.inference = inference;
+        this.takenEntityIds = takenEntityIds;
+    }
+    get state() { return this.cell.state; }
+    set state(value) { this.cell.state = value; }
+    live() { return this.state.clockRate !== null; }
+    draft(fields) {
+        return { seq: this.state.revision + 1, at: this.state.clock, witnessIds: witnessesFor(this.state, fields), nearbyIds: nearbyFor(this.state, fields), ...fields };
+    }
+    commit(fields) {
+        const live = this.live();
+        // Deciding is private: a plan event shows others only the activity it starts, or nothing.
+        if (fields.kind === 'plan' && fields.observed === undefined && fields.perceivedBy === undefined)
+            fields = { ...fields, perceivedBy: [] };
+        const before = this.state;
+        this.state = applyLivingEvent(this.state, this.draft(fields));
+        // The record keeps the event as the world accepted it, with what reached people elsewhere.
+        const event = this.state.events.at(-1);
+        this.events.push(event);
+        this.cell.log?.push(event);
+        // In a live world acts do not move the clock, so only a turn-mode command counts their minutes.
+        if (!live && event.actorId !== this.state.playerId)
+            this.nonPlayerMinutes += event.minutes;
+        this.reportCounts(before, event);
+        return event;
+    }
+    // A vote the player is a member of, counted out of the player's sight, reaches the player as news where they are:
+    // the problem it settles then reads as settled to them, as it does to those who saw the count. Only the count's own
+    // settlement is news: a problem settled before the count, or in another way by the act that made it, is not.
+    reportCounts(before, event) {
+        const player = this.state.people[this.state.playerId];
+        for (const id of before.openDecisionIds ?? []) {
+            const decision = this.state.entities[id];
+            if (decision?.result === undefined || !decision.members?.includes(player.id) || decision.settles === undefined)
+                continue;
+            const tension = this.state.tensions.find(candidate => candidate.id === decision.settles);
+            const note = countNote(decision);
+            if (tension?.status !== 'settled' || tension.resolution !== note || tension.playerView?.status === 'settled')
+                continue;
+            this.commit({ kind: 'world', actorId: null, placeId: player.placeId, summary: `Word reaches ${player.name} that the votes on ${decision.name} were counted: ${decision.result}.`,
+                narration: null, outcome: null, minutes: 0, causeSeq: event.seq, importance: 6, suggestions: [], reach: 'here', notice: null, visibleTensionIds: [tension.id],
+                effects: [{ kind: 'tension.update', tensionId: tension.id, status: 'settled', note }] });
+        }
+    }
+    player() { return this.state.people[this.state.playerId]; }
+    // A person decides one thing at a time across every flow on this world: a second decision waits
+    // until the first is recorded, then reads the world as it is. A flow may decide again for someone it
+    // already holds. The turn covers the person's own decision and its record, never others' answers
+    // to it, so two people who speak to each other at once never wait on each other.
+    async takeTurn(personId) {
+        const turns = (this.cell.turns ??= new Map());
+        for (let held = turns.get(personId); held !== undefined && held.session !== this; held = turns.get(personId))
+            await held.done;
+        let turn = turns.get(personId);
+        if (turn === undefined) {
+            let end = () => { };
+            const done = new Promise(resolve => { end = resolve; });
+            turn = { session: this, depth: 0, done, end };
+            turns.set(personId, turn);
+        }
+        const mine = turn;
+        mine.depth += 1;
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            mine.depth -= 1;
+            if (mine.depth === 0) {
+                turns.delete(personId);
+                mine.end();
+            }
+        };
+    }
+    canSpend() { return this.calls < MAX_MODEL_CALLS_PER_COMMAND && this.nonPlayerMinutes < MAX_NONPLAYER_MINUTES_PER_COMMAND; }
+    canSpendOptional() {
+        if (!this.canSpend())
+            return false;
+        const due = this.state.schedule.some(item => item.at <= this.state.clock
+            && (item.kind === 'world' || item.kind === 'plan' || item.kind === 'reply' || item.kind === 'finish')
+            && (item.personId === null || (!this.state.people[item.personId]?.incapacitated && !this.state.people[item.personId]?.isPlayer)));
+        return !due || this.calls < MAX_MODEL_CALLS_PER_COMMAND - MAX_DUE_ITEMS_PER_STEP;
+    }
+    // With build, a host that makes the call wait may build it again from the world as it is when it goes.
+    async complete(call, actorId, causeSeq = null, build, wanted = () => true, lookup = true) {
+        if (this.state.paused)
+            throw new LivingWorldError('run-paused', 'The world is paused');
+        if (!this.canSpend())
+            throw new LivingWorldError('inference-unavailable', 'The world-turn budget is exhausted');
+        const originalSystem = call.system;
+        const selecting = lookup && build !== undefined && call.input.view === MODEL_VIEW_NOTE;
+        if (selecting) {
+            if (this.calls + 2 > MAX_MODEL_CALLS_PER_COMMAND)
+                throw new LivingWorldError('inference-unavailable', 'The world-turn budget cannot fit context selection and a decision');
+            call = { ...call, responseSchema: withContextLookup(call.responseSchema, call.input), input: contextSelectionInput(call.input),
+                system: 'Select context for the next decision. The input shows only part of the world. Read the current action, speech, message or plan. If it names a needed person whose ID is absent from the shown cards, request that exact name or ID in contextRequest. Never substitute someone else or infer that an omitted person is absent. Request at most two identities. Use an empty array when the shown people suffice. Do not decide or narrate the action yet.',
+            };
+        }
+        assertLivingModelCall(call);
+        const startedAt = performance.now();
+        let sent = { input: call.input, responseSchema: call.responseSchema, revision: this.state.revision, inputRefs: characterInputRefs(this.state, call, actorId, causeSeq) };
+        let builtFrom = this.state;
+        // Built again only when the world has changed since.
+        const rebuild = build === undefined ? undefined : () => {
+            if (this.state !== builtFrom) {
+                builtFrom = this.state;
+                const next = build();
+                if (selecting) {
+                    next.responseSchema = call.responseSchema;
+                    next.input = contextSelectionInput(next.input);
+                }
+                assertLivingModelCall({ ...call, ...next });
+                sent = { ...next, revision: this.state.revision, inputRefs: characterInputRefs(this.state, { ...call, ...next }, actorId, causeSeq) };
+            }
+            return sent;
+        };
+        this.calls += 1;
+        let answer;
+        try {
+            answer = await this.inference.complete({ ...call, actorId, ...sent,
+                stillWanted: () => !this.state.paused && this.state.status !== 'finished' && wanted(),
+                reserveRetry: () => {
+                    if (!this.canSpend())
+                        return false;
+                    this.calls += 1;
+                    return true;
+                }, ...(rebuild === undefined ? {} : { rebuild }) });
+        }
+        catch (error) {
+            this.audit.push({ phase: call.phase, role: call.role, actorId, status: 'failed', failureCode: error instanceof LivingWorldError ? error.code : 'inference-unavailable', inputSha256: sha256(sent.input), outputSha256: null, latencyMs: Math.round(performance.now() - startedAt) });
+            // The provider's own error stays attached, so the app can tell a rejected account from an outage.
+            throw error instanceof LivingWorldError ? error : new LivingWorldError('inference-unavailable', error instanceof Error ? error.message : 'The model did not answer', { cause: error });
+        }
+        this.audit.push({ phase: call.phase, role: call.role, actorId, status: 'accepted', failureCode: null, inputSha256: sha256(sent.input), outputSha256: sha256(answer), latencyMs: Math.round(performance.now() - startedAt) });
+        // A queued rebuild can need selection for the first time. Discard that proposal before any effects.
+        if (!selecting && lookup && build && sent.input.view === MODEL_VIEW_NOTE) {
+            return await this.complete({ ...call, ...build() }, actorId, causeSeq, build, wanted);
+        }
+        const requested = answer !== null && typeof answer === 'object' ? answer.contextRequest : undefined;
+        if (selecting || Array.isArray(requested) && requested.length > 0) {
+            if (!lookup || !build || !Array.isArray(requested) || requested.length > 2 || !requested.every(reference => typeof reference === 'string' && reference.length > 0 && reference.length <= 200)) {
+                this.rejectLast('inference-invalid');
+                throw new LivingWorldError('inference-invalid', 'A context lookup allows at most two exact identities and one follow-up');
+            }
+            const { focusIds, unavailable } = modelContextPeople(this.state, actorId, call.phase, sent.input, requested);
+            const focused = () => {
+                const next = build(focusIds);
+                return { ...next, input: { ...next.input, ...(unavailable.length === 0 ? {} : { contextLookup: { unavailable } }) } };
+            };
+            return await this.complete({ ...call, system: originalSystem, ...focused() }, actorId, causeSeq, focused, wanted, false);
+        }
+        return answer;
+    }
+    rejectLast(reason) {
+        const last = this.audit.at(-1);
+        if (last) {
+            last.status = 'rejected';
+            last.failureCode = reason;
+        }
+    }
+    step() { return { state: this.state, events: this.events, audit: this.audit, modelCalls: this.calls }; }
+}
+const quiet = { reach: 'here', notice: null };
+// Time away for home, sleep or an errand: a quarter hour to a day.
+const AWAY_MINUTES = { min: 15, max: 1440 };
+// Someone who goes home at night, or after a long day up, stays at least the night; by day, at least
+// two hours, so no one goes home every half hour and no one leaves at four for the whole evening.
+const GO_HOME_MINUTES = 480;
+const DAY_AWAY_MINUTES = 120;
+const NO_MODEL = { complete: async () => { throw new LivingWorldError('inference-unavailable', 'This step needs no model'); } };
+// A live world starts on the server clock at nowMs; a world without a clock rate moves with its events.
+export function startLivingWorld(definition, seed, nowMs) {
+    const initial = createLivingState(definition, seed);
+    const session = new Session({ state: initial }, NO_MODEL);
+    const authoredEffects = [
+        ...definition.kinds.map(kind => ({ kind: 'kind.define', definition: kind })),
+        ...definition.entities.map(entity => ({ kind: 'entity.create', entityId: entity.id, kindId: entity.kindId, name: entity.name, placeId: entity.placeId,
+            ...(entity.members ? { memberIds: entity.members } : {}), ...(entity.settles ? { settles: entity.settles } : {}), ...(entity.transfers ? { transfers: entity.transfers } : {}),
+            ...(entity.knownTo ? { knownTo: entity.knownTo } : {}), ...(entity.hidden ? { hidden: true } : {}) })),
+        // A paper is sealed after its words are written, whatever order its world lists them in.
+        ...definition.entities.flatMap(entity => Object.entries(entity.properties).sort(([left], [right]) => Number(left === 'sealed') - Number(right === 'sealed')).map(([propertyId, value]) => ({ kind: 'property.set', entityId: entity.id, propertyId, value }))),
+        ...definition.entities.flatMap(entity => Object.entries(entity.relations).map(([relationId, targetId]) => ({ kind: 'relation.set', entityId: entity.id, relationId, targetId }))),
+    ];
+    session.commit({
+        kind: 'opening', actorId: null, placeId: initial.people[initial.playerId].placeId, summary: initial.opening.title, narration: initial.opening.situation,
+        outcome: null, minutes: 0, effects: authoredEffects, causeSeq: null, importance: 8, suggestions: [], ...quiet,
+    });
+    if (definition.clock) {
+        if (nowMs === undefined)
+            throw new LivingWorldError('command-invalid', 'A live world starts at a real time');
+        session.commit(clockFields(false, definition.clock.rate, nowMs));
+    }
+    return session.step();
+}
+function clockFields(paused, rate, nowMs) {
+    return {
+        kind: 'clock', actorId: null, placeId: null, summary: paused ? 'The world is paused.' : `The world runs at ${rate} game minutes a minute.`,
+        narration: null, outcome: null, minutes: 0, effects: [{ kind: 'clock', paused, rate }], causeSeq: null, importance: 1, suggestions: [],
+        realAt: Math.floor(nowMs), ...quiet,
+    };
+}
+// The game time the server clock has reached at a real time.
+export function livingClockTarget(state, nowMs) {
+    return clockTargetAt(state, nowMs);
+}
+// Pauses, resumes or changes the speed of a live world, or makes a turn-mode world live.
+// The game time already reached is kept; after a pause the world resumes from that moment.
+export function setLivingClock(options) {
+    const session = new Session(options.cell, NO_MODEL);
+    const state = session.state;
+    if (state.status === 'finished')
+        throw new LivingWorldError('run-finished', 'This story has finished');
+    const rate = options.rate ?? state.clockRate;
+    if (rate === null || !Number.isInteger(rate) || rate < 1 || rate > MAX_CLOCK_RATE) {
+        throw new LivingWorldError('command-invalid', `The clock runs at 1 to ${MAX_CLOCK_RATE} game minutes a minute`);
+    }
+    const paused = options.paused ?? state.paused;
+    if (paused === state.paused && rate === state.clockRate)
+        return session.step();
+    session.commit(clockFields(paused, rate, options.nowMs));
+    return session.step();
+}
+// The next moment after now that something is due; the clock never passes it unsettled.
+function nextDueAfter(state) {
+    let next = null;
+    for (const list of [state.schedule, state.meterSchedule]) {
+        const item = list.find(candidate => candidate.at > state.clock);
+        if (item && (next === null || item.at < next))
+            next = item.at;
+    }
+    return next;
+}
+// Moves a live world's clock toward the server clock, stopping at the next due item and at an
+// optional limit, such as a host keeping the clock near decisions still waiting on the model.
+// With idleMinutes, a stretch in which nothing falls due is recorded only once it is that long.
+export function tickLivingWorld(cell, nowMs, options = {}) {
+    const state = cell.state;
+    if (state.clockRate === null || state.paused || state.status === 'finished')
+        return null;
+    // The tick records the whole millisecond it happened at, and reaches no further than that moment allows.
+    const realAt = Math.floor(nowMs);
+    const target = clockTargetAt(state, realAt);
+    const next = nextDueAfter(state);
+    const dueSoon = next !== null && next <= target;
+    if (!dueSoon && options.idleMinutes !== undefined && target - state.clock < options.idleMinutes)
+        return null;
+    const to = Math.min(target, next ?? Number.POSITIVE_INFINITY, options.limit ?? Number.POSITIVE_INFINITY);
+    if (to <= state.clock)
+        return null;
+    return new Session(cell, NO_MODEL).commit({
+        kind: 'tick', actorId: null, placeId: null, summary: `The clock reaches ${clockLabel(to)}.`, narration: null, outcome: null,
+        minutes: to - state.clock, effects: [], causeSeq: null, importance: 1, suggestions: [], realAt, ...quiet,
+    });
+}
+function recoveringPeople(state) {
+    return Object.values(state.people).filter(person => person.incapacitatedBy !== undefined && person.departed === undefined
+        && blockedByGate(state, person.id, 'incapacitate') === null).map(person => person.id);
+}
+// Everything the world has to do now, most pressing first: recoveries, due items, then anyone
+// in a live world with nothing to do, who decides at once.
+export function livingDueWork(state) {
+    if (state.paused || state.status === 'finished')
+        return [];
+    const work = recoveringPeople(state).map(personId => ({ kind: 'recover', personId }));
+    const due = [];
+    for (const list of [state.schedule, state.meterSchedule])
+        for (const item of list) {
+            if (item.at > state.clock)
+                break;
+            if (predictionReady(state, item))
+                due.push(item);
+        }
+    due.sort((left, right) => right.importance - left.importance || left.at - right.at || left.id.localeCompare(right.id));
+    work.push(...due.map((item) => ({ kind: 'due', item })));
+    if (state.clockRate !== null) {
+        for (const person of Object.values(state.people)) {
+            if (!person.isPlayer && !person.incapacitated && !person.departed && !hasPlanned(state, person.id))
+                work.push({ kind: 'decide', personId: person.id });
+        }
+    }
+    return work;
+}
+// Carries out one piece of the world's own work in its own session and call budget. Work that
+// another session already settled is skipped. Settled is false when the model could not answer.
+export async function runLivingWork(options) {
+    const session = new Session(options.cell, options.inference, options.takenEntityIds);
+    if (session.state.paused || session.state.status === 'finished')
+        return { ...session.step(), settled: false };
+    joinAvailableKinds(session, options.availableKinds ?? []);
+    const { work } = options;
+    const state = session.state;
+    let settled = true;
+    if (work.kind === 'recover') {
+        const person = state.people[work.personId];
+        if (person && recoveringPeople(state).includes(person.id)) {
+            session.commit({ kind: 'world', actorId: null, placeId: person.placeId, summary: `${person.name} can act again.`, narration: null, outcome: null, minutes: 0,
+                effects: [], causeSeq: null, importance: 2, suggestions: [], ...quiet });
+        }
+    }
+    else if (work.kind === 'decide') {
+        const person = state.people[work.personId];
+        if (person && !person.isPlayer && !person.incapacitated && !person.departed && !hasPlanned(state, person.id)) {
+            settled = await carryOutPlan(session, { id: generatedId(state.engine, 'idle', [state.revision + 1, person.id]), at: state.clock, personId: person.id, kind: 'plan', intent: 'idle',
+                placeId: null, targetId: null, sourceSeq: state.revision, importance: 1 }, false);
+        }
+    }
+    else {
+        const due = [...state.schedule, ...state.meterSchedule].find(item => item.id === work.item.id);
+        if (due && due.at <= state.clock)
+            settled = await settleItem(session, due);
+    }
+    return { ...session.step(), settled };
+}
+// Whether a person has something planned now; a promise to keep later is not a plan for now.
+function hasPlanned(state, personId) {
+    return state.schedule.some(item => item.personId === personId && !item.id.startsWith('keep-'));
+}
+// A decision a person makes about their own routine: no one else's act, message or happening waits on it.
+export function livingWorkIsRoutine(work) {
+    if (work.kind === 'decide')
+        return true;
+    return work.kind === 'due' && work.item.kind === 'plan' && work.item.personId !== null
+        && work.item.importance <= ROUTINE_PLAN_IMPORTANCE && !isDecision(work.item);
+}
+// Someone who has kept one activity for two game hours, carried on without deciding, is due a real
+// decision however far behind the world is, so no one stands in one plan for a whole day.
+const CARRY_ON_LIMIT_MINUTES = 120;
+function carriedOnTooLong(state, person) {
+    const history = person.planHistory ?? [];
+    const last = history.at(-1);
+    if (!last)
+        return false;
+    let since = last.at;
+    for (let index = history.length - 1; index >= 0 && history[index].intent === last.intent; index -= 1)
+        since = history[index].at;
+    return state.clock - since >= CARRY_ON_LIMIT_MINUTES;
+}
+// When a world falls behind its clock, someone with nothing pressing carries on with what they were
+// doing a while longer instead of waiting for the model, as when a decision names no activity. While
+// the model cannot answer at all, they carry on however long they have, since no decision can be made.
+export function carryOnLivingWork(options) {
+    const session = new Session(options.cell, NO_MODEL);
+    const state = session.state;
+    const { work } = options;
+    const personId = work.kind === 'decide' ? work.personId : work.kind === 'due' ? work.item.personId : null;
+    const person = personId === null ? undefined : state.people[personId];
+    const current = work.kind === 'due' ? state.schedule.some(item => item.id === work.item.id)
+        : work.kind === 'decide' && personId !== null && !hasPlanned(state, personId);
+    // Someone with a decision out is left to it; carrying them on meanwhile would overtake it.
+    if (state.paused || state.status === 'finished' || !livingWorkIsRoutine(work) || !current || !person || person.isPlayer || person.incapacitated || person.departed
+        || options.cell.turns?.has(person.id) || !options.modelDown && carriedOnTooLong(state, person)) {
+        return { ...session.step(), settled: false };
+    }
+    const plan = { intent: person.plan?.intent ?? 'Carry on with the day', ...(person.plan?.seen ? { seen: person.plan.seen } : {}),
+        placeId: null, targetId: null, inMinutes: DEFAULT_ACTIVITY_MINUTES };
+    session.commit({ kind: 'plan', actorId: person.id, placeId: person.placeId, summary: `${person.name} carries on: ${plan.intent}`.slice(0, 2000), narration: null, outcome: null,
+        minutes: 0, effects: planEffects(state, person.id, plan, state.revision + 1), causeSeq: null, importance: 1, suggestions: [], ...quiet });
+    return { ...session.step(), settled: true };
+}
+// Brings a live world up to the server clock: due work settles in order as the clock passes it.
+// Work the model cannot answer now stays due and the clock goes on. A paused world does nothing.
+export async function advanceLivingWorld(options) {
+    const events = [];
+    const audit = [];
+    let modelCalls = 0;
+    const failed = new Set();
+    const key = (work) => work.kind === 'due' ? `due:${work.item.id}` : `${work.kind}:${work.personId}`;
+    for (let guard = 0; guard < 100_000; guard += 1) {
+        if (options.cell.state.paused)
+            break;
+        const work = livingDueWork(options.cell.state).find(item => !failed.has(key(item)));
+        if (work) {
+            const step = await runLivingWork({ ...options, work });
+            events.push(...step.events);
+            audit.push(...step.audit);
+            modelCalls += step.modelCalls;
+            if (!step.settled || step.events.length === 0)
+                failed.add(key(work));
+            continue;
+        }
+        const tick = tickLivingWorld(options.cell, options.nowMs);
+        if (!tick)
+            break;
+        events.push(tick);
+        failed.clear();
+    }
+    return { state: options.cell.state, events, audit, modelCalls };
+}
+// takenEntityIds tells which proposed ids already belong to saved things this command did not load.
+// A live world takes the command at the present moment of its server clock and settles nothing
+// else: its own due work runs beside the command. A turn-mode world settles what fell due after it.
+export async function runLivingCommand(options) {
+    const cell = options.cell ?? { state: options.state };
+    if (cell.state.status === 'finished')
+        throw new LivingWorldError('run-finished', 'This story has finished');
+    if (cell.state.paused)
+        throw new LivingWorldError('run-paused', 'The world is paused. Resume it to act.');
+    if (cell.state.people[cell.state.playerId].incapacitated && options.command.kind !== 'finish') {
+        throw new LivingWorldError('command-invalid', 'You cannot act now');
+    }
+    const live = cell.state.clockRate !== null;
+    if (live && options.command.kind === 'wait')
+        throw new LivingWorldError('command-invalid', 'Time passes on its own here. Change the speed to make it pass faster.');
+    if (live && options.nowMs === undefined)
+        throw new LivingWorldError('command-invalid', 'A live world takes commands at a real time');
+    const session = new Session(cell, options.inference, options.takenEntityIds);
+    if (live) {
+        const tick = tickLivingWorld(cell, options.nowMs, options.tickLimit === undefined ? {} : { limit: options.tickLimit });
+        if (tick)
+            session.events.push(tick);
+    }
+    joinAvailableKinds(session, options.availableKinds ?? []);
+    const { command } = options;
+    try {
+        switch (command.kind) {
+            case 'move':
+                await movePlayer(session, command.placeId);
+                break;
+            case 'say':
+                await playerSpeaks(session, command.text, command.toIds);
+                break;
+            case 'attempt':
+                await adjudicate(session, session.state.playerId, requireText(command.text));
+                break;
+            case 'message':
+                playerMessages(session, command.toIds, command.text);
+                break;
+            case 'wait':
+                await playerWaits(session);
+                break;
+            case 'keep-playing':
+                keepPlaying(session);
+                break;
+            case 'finish':
+                await finish(session);
+                return session.step();
+            case 'vote':
+                playerVotes(session, command.decisionId, command.choice);
+                break;
+        }
+    }
+    catch (error) {
+        // In a live world the player's own act stands once it is recorded. What others would say or do
+        // about it but cannot now, for a silent model or a pause, is left to them; the command succeeds.
+        const recorded = session.events.some(event => event.actorId === session.state.playerId && event.kind !== 'tick');
+        if (!live || !recorded || !(error instanceof LivingWorldError) || !LATER_CODES.has(error.code))
+            throw error;
+    }
+    if (!live)
+        await settleDue(session);
+    return session.step();
+}
+// A defined kind joins this world once every kind it links to exists here; until then it stays requested.
+function joinAvailableKinds(session, availableKinds) {
+    let waiting = availableKinds.filter(definition => session.state.kindRequests.some(request => request.id === definition.id) && !session.state.kinds[definition.id]);
+    for (;;) {
+        const ready = waiting.filter(definition => definition.relations.every(relation => relation.targetKindId === definition.id || session.state.kinds[relation.targetKindId]));
+        if (ready.length === 0)
+            break;
+        for (const definition of ready) {
+            // A stored definition that today's checks reject stays out of this world; the command goes on.
+            try {
+                session.commit({
+                    kind: 'world', actorId: null, placeId: null, summary: `Kind ${definition.id} becomes available.`,
+                    narration: null, outcome: null, minutes: 0, effects: [{ kind: 'kind.define', definition }],
+                    causeSeq: null, importance: 1, suggestions: [], ...quiet,
+                });
+            }
+            catch (error) {
+                if (!(error instanceof LivingWorldError) || error.code !== 'effect-invalid')
+                    throw error;
+            }
+        }
+        waiting = waiting.filter(definition => !ready.includes(definition));
+    }
+}
+function requireText(text) {
+    const trimmed = text.trim();
+    if (trimmed === '' || Buffer.byteLength(trimmed, 'utf8') > PLAYER_MAX_TEXT_BYTES)
+        throw new LivingWorldError('command-invalid', `Say or try something in 1 to ${PLAYER_MAX_TEXT_BYTES} bytes`);
+    return trimmed;
+}
+function presentCharacters(state, placeId, except = null) {
+    return peopleAt(state, placeId).filter(id => id !== except && !state.people[id].isPlayer && !state.people[id].incapacitated);
+}
+// ---- Player commands -----------------------------------------------------------
+async function movePlayer(session, placeId) {
+    const route = () => {
+        const player = session.player();
+        const path = travelPath(session.state, player.placeId, placeId);
+        if (path === null)
+            throw new LivingWorldError('place-unreachable', 'That place cannot be reached from here');
+        if (path.length === 1)
+            throw new LivingWorldError('command-invalid', 'You are already there');
+        if (player.incapacitated)
+            throw new LivingWorldError('command-invalid', 'You cannot move now');
+        if (player.held && heldHere(session.state, player.id))
+            throw new LivingWorldError('command-invalid', `You cannot leave: ${player.held.reason}. Try something if you mean to get away.`);
+        const gate = blockedByGate(session.state, player.id, 'move');
+        if (gate) {
+            // The player hears what keeps them by the name they know it by, never its id.
+            const entity = session.state.entities[gate];
+            const known = entity && entity.knownTo.includes(player.id) ? entity.name : 'Something';
+            throw new LivingWorldError('command-invalid', `You cannot leave: ${known} keeps you here. Try something if you mean to get away.`);
+        }
+        return path;
+    };
+    route();
+    // A long act whose time has passed ends before the walk; its end may have moved or stopped the player.
+    await finishDue(session, session.state.playerId);
+    const path = route();
+    const player = session.player();
+    // A long act still under way is left behind, and the player is told so.
+    const leftBehind = session.state.engine >= WALK_OFF_ENGINE ? session.state.schedule.filter(item => item.kind === 'finish' && item.targetId === player.id).map(leaveOff) : [];
+    session.commit({
+        kind: 'move', actorId: player.id, placeId: player.placeId,
+        summary: `${player.name} leaves for ${session.state.places[placeId].name}`, narration: null, outcome: null,
+        minutes: (path.length - 1) * TRAVEL_MINUTES_PER_HOP, effects: [...leftBehind, { kind: 'move', personId: player.id, placeId }],
+        causeSeq: null, importance: 1, suggestions: [], ...quiet,
+    });
+}
+// The gate that blocks a kind of act for a person now, by name, or null.
+function gateAgainst(state, personId, actionKind) {
+    return gatesAgainst(state, personId, actionKind)[0] ?? null;
+}
+async function playerSpeaks(session, rawText, rawToIds) {
+    const gag = gateAgainst(session.state, session.state.playerId, 'speak');
+    if (gag)
+        throw new LivingWorldError('command-invalid', `You cannot speak now: ${gag.name}`);
+    const text = requireText(rawText);
+    const player = session.player();
+    const present = presentCharacters(session.state, player.placeId);
+    const toIds = [...new Set(rawToIds)];
+    for (const id of toIds)
+        if (!present.includes(id))
+            throw new LivingWorldError('person-absent', `${personLabel(session.state, id)} is not here`);
+    let listeners = toIds.length > 0 ? byTurn(session.state, player.placeId, toIds).slice(0, MAX_REACTORS) : chooseListeners(session.state, present);
+    let addressed = [...toIds];
+    let about = [];
+    // Things here or in the speaker's hand that the words could be about.
+    // The newest things here that the speaker knows of, as a scene lists them.
+    // From engine 49 words may also be about what the speaker knows lies elsewhere, the latest changed first.
+    // However full the room, eight are named: what the speaker holds, then the newest here, then elsewhere.
+    const known = (session.state.entityPlaceIds[player.placeId] ?? []).filter(id => session.state.entities[id].knownTo.includes(player.id));
+    const objectsHere = Object.values(session.state.objects).filter(object => (object.placeId === player.placeId || object.holderId === player.id)
+        && (!object.hidden || object.holderId === player.id || object.custodyKnownTo.includes(player.id)));
+    const thingsHere = session.state.engine < THING_MEMORY_ENGINE ? [] : [...new Set([
+            ...known.filter(id => session.state.entities[id].holderId === player.id), ...objectsHere.filter(object => object.holderId === player.id).map(object => object.id),
+            ...[...known].reverse(), ...[...objectsHere].sort((left, right) => right.introducedAt - left.introducedAt || left.id.localeCompare(right.id)).map(object => object.id),
+            ...(session.state.engine < THINGS_SEEN_ENGINE ? [] : knownElsewhere(session.state, player.id, player.placeId))
+        ])].slice(0, SPEECH_THINGS).sort();
+    // People the player has seen who are elsewhere may be the ones meant; such words go to the room.
+    const elsewhere = Object.keys(session.state.sightings).filter(id => !present.includes(id) && session.state.people[id] !== undefined
+        && session.state.people[id].departed === undefined && id !== player.id).sort();
+    // Whom the player was just talking with, from the talk under way here.
+    const talk = session.state.conversations.filter(conversation => conversation.placeId === player.placeId && conversation.endedAt === null)
+        .flatMap(conversation => conversation.lines).sort((left, right) => left.seq - right.seq);
+    const exchange = { youLastSpokeTo: [...(talk.filter(line => line.speakerId === player.id).at(-1)?.toIds ?? [])],
+        lastSpokeToYou: talk.filter(line => line.speakerId !== player.id && line.toIds.includes(player.id)).at(-1)?.speakerId ?? null };
+    let importance = 3;
+    let pressure = null;
+    let promised = null;
+    let loud = false;
+    const nearbyListeners = nearbyFor(session.state, { placeId: player.placeId, reach: 'nearby', effects: [] });
+    if (listeners.length > 0 || nearbyListeners.length > 0) {
+        try {
+            const talking = new Set([...toIds, ...exchange.youLastSpokeTo, ...(exchange.lastSpokeToYou ? [exchange.lastSpokeToYou] : [])]);
+            const held = new Set([...Object.values(session.state.objects).filter(object => object.holderId === player.id).map(object => object.id),
+                ...thingsHere.filter(id => session.state.entities[id]?.holderId === player.id)]);
+            const build = (focusIds = []) => {
+                const input = fitSpeechInput(session.state, { speaker: { name: player.name, role: player.role }, words: text,
+                    listeners: present.map(id => ({ id, name: session.state.people[id].name, role: session.state.people[id].role })),
+                    ...(elsewhere.length === 0 ? {} : { elsewhere: elsewhere.map(id => ({ id, name: session.state.people[id].name })) }),
+                    exchange,
+                    ...(thingsHere.length === 0 ? {} : { things: thingsHere.map(id => ({ id, name: session.state.entities[id]?.name ?? session.state.objects[id].name })) }),
+                    setting: speechSetting(session.state), place: session.state.places[player.placeId].name }, new Set([...focusIds, ...talking]), held);
+                const ids = (list) => (list ?? []).map(item => item.id);
+                return { input, responseSchema: scopedSpeechImpactResponseSchema([...ids(input.listeners), ...ids(input.elsewhere)], ids(input.things)) };
+            };
+            const assessment = await session.complete({
+                role: 'game-master', phase: 'speech-impact', system: SPEECH_IMPACT_SYSTEM, ...build(), ...LIVING_INFERENCE_LIMITS['speech-impact'],
+            }, player.id, null, build);
+            importance = clampInt(assessment.importance, 1, 10, 3);
+            // A line presses on its listeners; a promise out loud is one they are owed from now on.
+            const pressed = assessment.pressure !== null && typeof assessment.pressure === 'object' ? assessment.pressure
+                : typeof assessment.pressure === 'string' ? { kind: 'demand', text: assessment.pressure, dueInMinutes: null } : null;
+            pressure = pressed && typeof pressed.text === 'string' && pressed.text.trim() !== '' ? pressed.text.trim().slice(0, 200) : null;
+            if (pressure !== null && pressed?.kind === 'promise')
+                promised = { text: pressure, dueInMinutes: typeof pressed.dueInMinutes === 'number' ? clampInt(pressed.dueInMinutes, 0, 100_000, 0) : null };
+            loud ||= assessment.loud === true;
+            // Words said to the room but meant for someone here by name go to them; words for someone elsewhere go to the room.
+            const named = Array.isArray(assessment.addressedIds) ? [...new Set(assessment.addressedIds.filter((id) => typeof id === 'string' && present.includes(id)))] : [];
+            if (toIds.length === 0 && named.length > 0) {
+                addressed = named;
+                listeners = byTurn(session.state, player.placeId, named).slice(0, MAX_REACTORS);
+            }
+            about = Array.isArray(assessment.aboutIds) ? [...new Set(assessment.aboutIds.filter((id) => typeof id === 'string' && thingsHere.includes(id)))].slice(0, 4) : [];
+        }
+        catch (error) {
+            if (!(error instanceof LivingWorldError) || (error.code !== 'inference-invalid' && error.code !== 'inference-unavailable'))
+                throw error;
+        }
+    }
+    // The world went on while the words were weighed; only those still here hear them.
+    const stillHere = presentCharacters(session.state, player.placeId);
+    const heardBy = addressed.filter(id => stillHere.includes(id));
+    // Anyone a serious line was said to who does not answer now has it to decide later.
+    const seq = session.state.revision + 1;
+    const leftOut = importance >= SHOCK_IMPORTANCE ? heardBy.filter(id => !listeners.includes(id)) : [];
+    const decideLater = leftOut.flatMap(id => shockPlanEffects(session.state, id, generatedId(session.state.engine, 'shock', [seq, id]), `Decide what to do about what ${player.name} said to you: "${text}"`.slice(0, 600), SHOCK_PLAN_DELAY_MINUTES, player.id));
+    const event = session.commit({
+        kind: 'speech', actorId: player.id, placeId: player.placeId,
+        summary: `${player.name} says to ${heardBy.length === 0 ? 'the room' : heardBy.map(id => personLabel(session.state, id)).join(' and ')}: "${text}"`.slice(0, 2000),
+        narration: null, outcome: null, minutes: SPEECH_MINUTES,
+        effects: [{ kind: 'say', personId: player.id, text, toIds: heardBy },
+            ...(promised === null ? [] : heardBy.map((id) => ({ kind: 'commitment', commitmentId: generatedId(session.state.engine, 'promise', [seq, id]), personId: player.id, toId: id,
+                text: promised.text, dueInMinutes: promised.dueInMinutes }))), ...decideLater],
+        causeSeq: null, importance, suggestions: [], ...(about.length === 0 ? {} : { thingIds: about }),
+        reach: loud ? 'nearby' : 'here', notice: loud ? `A shout comes from ${session.state.places[player.placeId].name}.` : null,
+    });
+    await react(session, listeners.filter(id => event.witnessIds.includes(id)), event, { kind: 'speech', actorId: player.id, text, narration: null, pressure }, 'reply', false);
+    if (loud)
+        await reactNearby(session, event);
+}
+// The player casts their own vote, seen by those present; no model reads it from their words.
+function playerVotes(session, decisionId, choice) {
+    const player = session.player();
+    const decision = session.state.entities[decisionId];
+    if (!decision?.members?.includes(player.id))
+        throw new LivingWorldError('command-invalid', 'You have no vote on that');
+    const shut = votingShut(session.state, decision, session.state.clock);
+    if (shut)
+        throw new LivingWorldError('command-invalid', `${decision.name} ${shut}`);
+    if (decision.ballots?.[player.id] !== undefined)
+        throw new LivingWorldError('command-invalid', `You have already voted on ${decision.name}`);
+    const summary = `${player.name} votes ${choice} on ${decision.name}`;
+    session.commit({ kind: 'attempt', actorId: player.id, placeId: player.placeId, summary, narration: `You vote ${choice} on ${decision.name}.`, outcome: 'succeeded',
+        minutes: 1, effects: [{ kind: 'ballot', entityId: decision.id, personId: player.id, choice }], causeSeq: null, importance: 4, suggestions: [], ...quiet, observed: summary });
+}
+// Those spoken to, the one who spoke least lately first, so the same few do not always answer.
+function byTurn(state, placeId, ids) {
+    const lines = state.conversations.filter(conversation => conversation.placeId === placeId && conversation.endedAt === null).flatMap(conversation => conversation.lines);
+    const lastSpoke = (id) => Math.max(-1, ...lines.filter(line => line.speakerId === id).map(line => line.seq));
+    return [...ids].sort((left, right) => lastSpoke(left) - lastSpoke(right) || left.localeCompare(right));
+}
+function playerMessages(session, rawToIds, rawText) {
+    const gag = gateAgainst(session.state, session.state.playerId, 'message');
+    if (gag)
+        throw new LivingWorldError('command-invalid', `You cannot send messages now: ${gag.name}`);
+    const text = requireText(rawText);
+    const player = session.player();
+    const toIds = [...new Set(rawToIds)];
+    if (toIds.length === 0 || toIds.length > 8)
+        throw new LivingWorldError('command-invalid', 'A message needs one to eight recipients');
+    for (const id of toIds)
+        if (!session.state.people[id] || session.state.people[id].isPlayer)
+            throw new LivingWorldError('command-invalid', `${id} cannot receive messages`);
+    // A message to someone who left still goes, as a note to one who quit would; no answer comes.
+    const readers = toIds.filter(id => session.state.people[id].departed === undefined);
+    const seq = session.state.revision + 1;
+    const travel = session.state.messageTravel;
+    session.commit({
+        kind: 'message', actorId: player.id, placeId: player.placeId,
+        summary: `${player.name} sends a message to ${toIds.map(id => personLabel(session.state, id)).join(', ')}${travel ? ` ${travel.how}` : ''}`, narration: null, outcome: null, minutes: MESSAGE_MINUTES,
+        effects: travel ? [dispatch(seq, 0, { fromId: player.id, toIds, text, replies: true })] : [
+            { kind: 'message', fromId: player.id, toIds, text },
+            ...readers.map((id) => ({ kind: 'schedule', scheduledId: generatedId(session.state.engine, 'reply', [seq, id]), personId: id, inMinutes: MESSAGE_REPLY_DELAY_MINUTES, intent: text, placeId: null, targetId: player.id, scheduleKind: 'reply' })),
+        ],
+        causeSeq: null, importance: 3, suggestions: [], ...quiet,
+    });
+}
+// Weighing the player's words names this many things, so its input stays one size however full the room.
+const SPEECH_THINGS = 8;
+// The things someone knows of that lie elsewhere, or nowhere, the latest changed first.
+const KNOWN_ELSEWHERE = 8;
+function knownElsewhere(state, personId, placeId) {
+    const lastChanged = (entity) => Math.max(entity.introducedSeq, ...Object.values(entity.properties).map(slot => slot.changedSeq));
+    return Object.values(state.entities).filter(entity => entity.placeId !== placeId && entity.knownTo.includes(personId))
+        .sort((left, right) => lastChanged(right) - lastChanged(left) || left.id.localeCompare(right.id)).slice(0, KNOWN_ELSEWHERE).map(entity => entity.id);
+}
+// Where the world says messages travel, a message is handed on now and arrives later.
+function dispatch(seq, index, message) {
+    const { sourcePersonId, request, ...rest } = message;
+    return { kind: 'dispatch', dispatchId: `deliver-${seq}-${index}`, ...rest, toIds: [...rest.toIds],
+        ...(sourcePersonId ? { sourcePersonId } : {}), ...(request ? { request } : {}) };
+}
+// A message on its way reaches those still in the world, with no model. A reader who answers
+// does so a little after it arrives, and the answer travels back the same way.
+function deliverMessage(session, due) {
+    const state = session.state;
+    const delivery = due.delivery;
+    const readers = delivery.toIds.filter(id => state.people[id] && !state.people[id].departed);
+    const seq = state.revision + 1;
+    const from = personLabel(state, delivery.fromId);
+    const effects = [{ kind: 'unschedule', scheduledId: due.id }];
+    if (readers.length > 0) {
+        effects.push({ kind: 'message', fromId: delivery.fromId, toIds: readers, text: delivery.text });
+        const request = delivery.request;
+        if (request && readers.length === 1)
+            effects.push({ kind: 'request.open', requestId: request.requestId, senderId: delivery.fromId, receiverId: readers[0], topic: request.topic });
+        if (delivery.replies) {
+            effects.push(...readers.filter(id => !state.people[id].isPlayer && id !== delivery.fromId).map((id) => ({ kind: 'schedule', scheduledId: generatedId(session.state.engine, 'reply', [seq, id]), personId: id,
+                inMinutes: MESSAGE_REPLY_DELAY_MINUTES, intent: session.state.engine >= FULL_SCHEDULE_INTENT_ENGINE ? delivery.text : delivery.text.slice(0, MAX_LINE), placeId: null, targetId: delivery.fromId, scheduleKind: 'reply' })));
+        }
+    }
+    session.commit({
+        kind: 'message', actorId: null, placeId: null,
+        summary: readers.length > 0 ? `A message from ${from} reaches ${readers.map(id => personLabel(state, id)).join(', ')}` : `A message from ${from} finds no one to read it`,
+        narration: null, outcome: null, minutes: 0, effects, causeSeq: due.sourceSeq || null, importance: due.importance, suggestions: [], ...quiet,
+    });
+    return Promise.resolve(true);
+}
+function nextDue(state) {
+    return state.schedule.find(item => item.personId === null || (!state.people[item.personId]?.incapacitated && !state.people[item.personId]?.isPlayer));
+}
+async function playerWaits(session) {
+    const player = session.player();
+    const next = nextDue(session.state);
+    const untilNext = next ? next.at - session.state.clock : null;
+    session.commit({
+        kind: 'wait', actorId: player.id, placeId: player.placeId, summary: untilNext !== null && untilNext > 0 ? `${player.name} waits until something happens` : `${player.name} waits a while`,
+        narration: null, outcome: null, minutes: untilNext === null ? IDLE_WAIT_MINUTES : untilNext > 0 ? Math.min(untilNext, IDLE_WAIT_MINUTES) : OVERDUE_WAIT_MINUTES, effects: [], causeSeq: null, importance: 1, suggestions: [], ...quiet,
+    });
+    if (!next)
+        await idleTick(session);
+}
+function keepPlaying(session) {
+    const stop = session.state.stoppingPoint;
+    if (!stop)
+        throw new LivingWorldError('command-invalid', 'There is no stopping point to pass');
+    session.commit({
+        kind: 'keep-playing', actorId: session.state.playerId, placeId: null, summary: `${session.player().name} keeps going after: ${stop.title}`.slice(0, 2000),
+        narration: null, outcome: null, minutes: 0, effects: [], causeSeq: null, importance: 1, suggestions: [], ...quiet,
+    });
+}
+const recapCardSchema = endingSchema.extend({ title: z.string().trim().min(1).max(200) });
+async function finish(session) {
+    const answer = await session.complete({
+        role: 'narrator', phase: 'epilogue', system: NARRATOR_EPILOGUE_SYSTEM, input: epilogueInput(session.state), responseSchema: epilogueResponseSchema,
+        ...LIVING_INFERENCE_LIMITS.epilogue,
+    }, null);
+    const card = recapCardSchema.safeParse(answer);
+    if (!card.success) {
+        session.rejectLast('epilogue-invalid');
+        throw new LivingWorldError('inference-invalid', 'The epilogue is malformed');
+    }
+    const { title, ...ending } = card.data;
+    session.commit({
+        kind: 'finish', actorId: session.state.playerId, placeId: null, summary: title, narration: ending.highlights.join(' ').slice(0, 2000),
+        outcome: null, minutes: 0, effects: [], causeSeq: null, importance: 10, suggestions: [], ending, ...quiet,
+    });
+}
+// Speech to the room reaches those it names first, then whoever is most involved with the player.
+function chooseListeners(state, present) {
+    const involved = new Set(state.tensions.filter(tension => tension.status === 'open').flatMap(tension => tension.participantIds));
+    const warmth = (id) => Math.abs(state.people[id].relationships[state.playerId]?.warmth ?? 0);
+    return [...present].sort((a, b) => Number(involved.has(b)) - Number(involved.has(a)) || warmth(b) - warmth(a) || a.localeCompare(b)).slice(0, MAX_REACTORS);
+}
+async function adjudicate(session, actorId, attempt, finishing = null) {
+    const able = () => {
+        const actor = session.state.people[actorId];
+        if (actor.incapacitated)
+            throw new LivingWorldError('command-invalid', `${actor.name} cannot act now`);
+        return actor;
+    };
+    able();
+    // A long act whose time has passed ends as it was ruled before its actor does anything new.
+    if (finishing === null)
+        await finishDue(session, actorId);
+    const actor = able();
+    // A new act sets aside a long act of the actor's still under way, and tells them; ruling one's end clears it.
+    const clears = (state) => state.schedule.filter(item => item.kind === 'finish' && item.targetId === actorId)
+        .map(item => item.id === finishing?.item.id ? { kind: 'unschedule', scheduledId: item.id } : leaveOff(item));
+    const causeSeq = finishing ? finishing.item.sourceSeq || null : null;
+    const verb = finishing ? 'finishes' : 'tries';
+    const gate = gateAgainst(session.state, actorId, 'act');
+    if (gate) {
+        // A gate on acting settles the attempt itself; there is nothing for the referee to weigh.
+        session.commit({
+            kind: 'attempt', actorId, placeId: actor.placeId, summary: `${actor.name} ${verb}: "${attempt}" — failed. ${gate.name} stops ${actor.name}.`.slice(0, 2000),
+            narration: `${gate.name} stops ${actor.name}.`, outcome: 'failed', minutes: 1, effects: clears(session.state), causeSeq, importance: 1, suggestions: [], reach: 'here', notice: null,
+        });
+        return;
+    }
+    const begun = finishing ? { begunAt: clockLabel(finishing.item.held?.at ?? finishing.item.at), changed: finishing.changed } : undefined;
+    await resolve(session, {
+        phase: 'attempt', actorId, placeId: actor.placeId, kind: 'attempt', causeSeq, extraEffects: [], clears, attempt, finishing: finishing !== null,
+        ...(finishing ? { finishingId: finishing.item.id } : {}),
+        input: (errors, fitted, focusIds) => gameMasterAttemptInput(session.state, actorId, attempt, errors, fitted, begun, focusIds),
+        summary: ruling => `${actor.name} ${verb}: "${attempt}" — ${ruling.outcome}. ${ruling.record}`,
+        trigger: ruling => ({ kind: 'attempt', actorId, text: ruling.observed ?? `${actor.name} acts nearby.`, narration: null }),
+    });
+}
+// A long act set aside before its end: its item leaves the schedule, naming what it was and when it began.
+function leaveOff(item) {
+    return { kind: 'unschedule', scheduledId: item.id, leftOff: { intent: item.intent, begunAt: item.held?.at ?? item.at } };
+}
+// Each long act of this actor whose time has passed ends before they do anything else.
+async function finishDue(session, actorId) {
+    for (const item of session.state.schedule.filter(candidate => candidate.kind === 'finish' && candidate.targetId === actorId && candidate.at <= session.state.clock)) {
+        if (session.state.schedule.some(candidate => candidate.id === item.id))
+            await finishAct(session, item);
+    }
+}
+// A long act ends when its time has passed. When no one and nothing it names has changed, its held
+// ruling applies as it was made; otherwise the Game Master rules its end on the world as it is. An
+// act whose actor left the place, or can no longer act, or whose end cannot be ruled, is left where it began.
+async function finishAct(session, due) {
+    const actor = due.targetId === null ? undefined : session.state.people[due.targetId];
+    // Its actor is told it ended unfinished, and anyone there sees them stop.
+    const setAside = () => {
+        const now = actor === undefined ? undefined : session.state.people[actor.id];
+        session.commit({ kind: 'world', actorId: now?.id ?? null, placeId: now && now.departed === undefined && now.away === undefined ? now.placeId : null,
+            summary: `${actor?.name ?? 'Someone'} leaves off: ${due.intent}`.slice(0, 2000), narration: now?.isPlayer ? 'You stop before finishing.' : null,
+            observed: `${actor?.name ?? 'Someone'} stops before finishing.`, outcome: null, minutes: 0,
+            effects: [leaveOff(due)], causeSeq: due.sourceSeq || null, importance: 1, suggestions: [], ...quiet });
+        return true;
+    };
+    if (!actor || actor.incapacitated || actor.departed || actor.away || actor.placeId !== due.placeId || !due.held)
+        return setAside();
+    const held = due.held;
+    const state = session.state;
+    const changed = Object.entries(held.standing).filter(([id, was]) => standing(state, id) !== was).map(([id]) => nowStanding(state, id));
+    if (changed.length === 0) {
+        const fields = held.fields;
+        // Whoever is still there perceives it; people who walked in meanwhile only see the end.
+        const witnesses = witnessesFor(state, { actorId: actor.id, placeId: due.placeId });
+        const ending = { ...fields, effects: [{ kind: 'unschedule', scheduledId: due.id }, ...fields.effects], causeSeq: due.sourceSeq || null,
+            perceivedBy: (fields.perceivedBy ?? []).filter(id => witnesses.includes(id)) };
+        // A serious act leaves its witnesses, as they are now, something to decide. An engine-39 held
+        // ruling, which kept no record, already carries those consequences.
+        if (ending.importance >= SHOCK_IMPORTANCE && ending.outcome !== 'impossible' && held.record !== undefined) {
+            const draft = session.draft(ending);
+            ending.effects = [...ending.effects, ...seriousConsequences(state, { actorId: actor.id, placeId: due.placeId, seq: draft.seq, minutes: 0, record: held.record ?? due.intent,
+                    observed: ending.observed ?? null, reactorIds: held.reactorIds, perceivers: ending.perceivedBy ?? [], effects: fields.effects, notice: ending.notice, nearbyIds: draft.nearbyIds })];
+        }
+        let event = null;
+        try {
+            event = session.commit(ending);
+        }
+        catch (error) {
+            if (!(error instanceof LivingWorldError))
+                throw error;
+        }
+        if (event) {
+            const reactorIds = held.reactorIds.filter(id => event.perceivedBy?.includes(id) && presentCharacters(session.state, due.placeId, actor.id).includes(id));
+            await react(session, reactorIds, event, { kind: 'attempt', actorId: actor.id, text: event.observed ?? `${actor.name} acts nearby.`, narration: null }, 'reaction', true);
+            await reactNearby(session, event);
+            return true;
+        }
+    }
+    try {
+        await adjudicate(session, actor.id, due.intent, { item: due, changed });
+    }
+    catch (error) {
+        if (!(error instanceof LivingWorldError))
+            throw error;
+        if (error.code === 'inference-unavailable')
+            return false;
+        if (error.code !== 'inference-invalid' && error.code !== 'command-invalid')
+            throw error;
+        return setAside();
+    }
+    // The actor was struck down while it was ruled: the act ends there.
+    return session.state.schedule.some(item => item.id === due.id) ? setAside() : true;
+}
+// The Game Master rules; the reducer checks; an unacceptable ruling goes back once with
+// its reasons. Then the people there react, someone nearby may notice, and a shock
+// leaves every witness deciding what to do about it.
+async function resolve(session, job) {
+    let errors = [];
+    let extraRepair = false;
+    let staleRulings = 0;
+    for (let round = 0; round < 3; round += 1) {
+        if (round === 2 && (!extraRepair || !session.canSpend()))
+            break;
+        // The ruling is checked against the world the model was shown, whenever the call was built.
+        let asked = session.state;
+        const build = (focusIds = []) => {
+            asked = session.state;
+            const input = job.input(errors, true, focusIds);
+            // The answer may name only what the model was shown.
+            return { input, responseSchema: scopedAttemptResponseSchema(input) };
+        };
+        const answer = await session.complete({ role: 'game-master', phase: job.phase, system: GAME_MASTER_SYSTEM, ...build(), ...LIVING_INFERENCE_LIMITS[job.phase] }, job.actorId, null, build);
+        const ruling = parseRuling(answer);
+        // A proposed id already held by a saved thing outside this command's view is taken as well.
+        const proposedIds = ruling.effects.flatMap(effect => effect.kind === 'entity.create' && typeof effect.entityId === 'string' ? [effect.entityId] : []);
+        const usedCreationIds = new Set(proposedIds.length === 0 ? [] : await session.takenEntityIds(proposedIds));
+        // The world goes on while the Game Master rules. A ruling is checked against the world as it is
+        // when it returns; when a person or thing it names has changed since, it is ruled again.
+        const state = session.state;
+        if (job.actorId !== null && (!state.people[job.actorId] || state.people[job.actorId].incapacitated))
+            return;
+        if (job.finishingId !== undefined && !state.schedule.some(item => item.id === job.finishingId))
+            return;
+        const extra = [...job.extraEffects, ...(job.clears ? job.clears(state) : [])];
+        const placeId = job.actorId !== null && job.kind === 'attempt' ? state.people[job.actorId].placeId : job.placeId;
+        if (state !== asked) {
+            const changed = changedReferences(asked, state, job.actorId, ruling);
+            if (changed.length > 0 && staleRulings < MAX_STALE_RULINGS && session.canSpend()) {
+                staleRulings += 1;
+                round -= 1;
+                session.rejectLast('ruling-stale');
+                errors = [`While this was ruled, the scene changed: ${changed.join('; ')}. Rule on the scene as it is now.`];
+                continue;
+            }
+        }
+        if (job.nothingNew?.(ruling)) {
+            session.commit({ kind: 'world', actorId: null, placeId, summary: 'Nothing new came of it', narration: null, outcome: null, minutes: 0,
+                effects: extra, causeSeq: null, importance: 1, suggestions: [], ...quiet, perceivedBy: [] });
+            return;
+        }
+        // A gate on this kind of act voids the ruling's changes: the act fails and nothing lasts.
+        const gate = job.actorId !== null && ruling.actionKind !== null ? gateAgainst(state, job.actorId, ruling.actionKind) : null;
+        if (gate) {
+            ruling.outcome = 'failed';
+            ruling.effects = [];
+            ruling.settledTensionId = null;
+            ruling.newTension = null;
+            ruling.narration = `${ruling.narration} ${gate.name} stops ${state.people[job.actorId].name}.`.slice(0, 2000);
+        }
+        // Only the player's own act may take a long stretch of the player's time; a character's act or a world
+        // happening resolves in a few minutes so the player's clock does not jump while they stand there.
+        if (job.actorId !== state.playerId && !session.live()) {
+            ruling.minutes = Math.min(ruling.minutes, OTHERS_MAX_MINUTES, Math.max(0, MAX_NONPLAYER_MINUTES_PER_COMMAND - session.nonPlayerMinutes));
+        }
+        const seq = state.revision + 1;
+        const translated = ruling.effects.flatMap((effect, index, all) => {
+            // A repeated identical change says nothing new; two unnamed creations are two new things.
+            if (!anonymousCreation(effect) && all.slice(0, index).some(prior => isDeepStrictEqual(prior, effect)))
+                return [];
+            const result = translateGmEffect(state, effect, seq, index, placeId, usedCreationIds);
+            if ('effect' in result) {
+                const id = createdIdentity(result.effect);
+                if (id !== null)
+                    usedCreationIds.add(id);
+            }
+            return [result];
+        });
+        const failures = translated.filter((item) => 'error' in item).map(item => item.error);
+        if (ruling.kindFit === 'missing' && ruling.newKind === null)
+            failures.push('stateKindFit missing needs stateNewKind with a valid id, name, and general meaning');
+        if (ruling.kindFit !== 'missing' && ruling.newKind !== null)
+            failures.push('stateNewKind needs stateKindFit missing');
+        if (ruling.newKind !== null && state.kinds[ruling.newKind.id]) {
+            failures.push(`Kind ${ruling.newKind.id} already exists; use it in entity.create or request a different missing kind`);
+        }
+        const witnesses = witnessesFor(state, { actorId: job.actorId, placeId: placeId });
+        const perceivers = job.seenByAll ? witnesses : ruling.perceivedBy ?? witnesses;
+        if (new Set(perceivers).size !== perceivers.length || perceivers.some(id => !witnesses.includes(id)))
+            failures.push('perceivedBy must name only distinct people present at the act');
+        // An impossible attempt never happened, so it changes nothing but how people feel about the asking.
+        const allowedWhenImpossible = new Set(['mood', 'relationship', 'belief']);
+        // New places and people come first, so a ruling's other changes may name them in any order.
+        const first = (effect) => effect.kind === 'place.create' ? 0 : effect.kind === 'person.create' ? 1 : 2;
+        const effects = translated.filter((item) => 'effect' in item).map(item => item.effect)
+            .filter(effect => ruling.outcome !== 'impossible' || allowedWhenImpossible.has(effect.kind))
+            .sort((left, right) => first(left) - first(right));
+        const objectChanges = new Map();
+        // One act takes each person to at most one neighboring place.
+        const moved = new Set();
+        // A change refused on its own is left out of a happening's last ruling as well.
+        const refused = new Set();
+        for (const effect of effects) {
+            if (job.movesNoMoney && (effect.kind === 'transfer' || effect.kind === 'money')) {
+                failures.push('A problem going on by itself moves no money; money moves by acts and by the world\'s own written happenings');
+                refused.add(effect);
+                continue;
+            }
+            // A happening moves, sends away or removes no one who was already here: people go by their own decisions.
+            if (job.kind === 'world' && (effect.kind === 'move' || effect.kind === 'person.away' || effect.kind === 'person.leave') && state.people[effect.personId]) {
+                failures.push(`A happening moves no one; ${state.people[effect.personId].name} goes where they decide to go`);
+                refused.add(effect);
+                continue;
+            }
+            if (effect.kind === 'move' && state.people[effect.personId]?.placeId === effect.placeId) {
+                failures.push(`Person ${effect.personId} is already at ${effect.placeId}`);
+            }
+            if (effect.kind === 'move' && state.people[effect.personId]
+                && !state.places[state.people[effect.personId].placeId].connections.includes(effect.placeId)) {
+                failures.push(`Person ${effect.personId} can only go to a neighboring place in one act`);
+            }
+            if (effect.kind === 'move' && moved.has(effect.personId))
+                failures.push(`Person ${effect.personId} moves more than once in one act`);
+            if (effect.kind === 'move')
+                moved.add(effect.personId);
+            if (effect.kind === 'entity.create' && effect.placeId !== null && effect.placeId !== placeId) {
+                failures.push(`A new ${effect.kindId} must be created at ${placeId}, where this act happens, or belong to no place`);
+            }
+            if (effect.kind === 'object.update') {
+                const previous = objectChanges.get(effect.objectId) ?? state.objects[effect.objectId];
+                if (!previous)
+                    continue;
+                const next = { placeId: previous.placeId, holderId: previous.holderId,
+                    ownerId: previous.ownerId, condition: previous.condition };
+                if (effect.placeId !== null) {
+                    next.placeId = effect.placeId;
+                    next.holderId = null;
+                }
+                if (effect.holderId !== null) {
+                    next.holderId = effect.holderId;
+                    next.placeId = null;
+                }
+                if (effect.ownerId !== null)
+                    next.ownerId = effect.ownerId;
+                if (effect.condition !== null)
+                    next.condition = effect.condition;
+                objectChanges.set(effect.objectId, next);
+            }
+        }
+        // A ruling changes only what is at hand where it happens, and what a happening concerns.
+        const heldHere = (holderId) => holderId !== null && state.people[holderId]?.placeId === placeId;
+        const where = (thing) => thing.holderId !== null && state.people[thing.holderId]
+            ? `with ${state.people[thing.holderId].name} in ${state.places[state.people[thing.holderId].placeId]?.name ?? 'another place'}` : `in ${state.places[thing.placeId ?? '']?.name ?? 'another place'}`;
+        const atHand = () => [...Object.values(state.objects).filter(object => object.placeId === placeId || heldHere(object.holderId)).map(object => object.name),
+            ...(state.entityPlaceIds[placeId] ?? []).map(id => state.entities[id].name)];
+        const elsewhere = (thing) => `${thing.name} is ${where(thing)}, not in ${state.places[placeId].name}, where this happens; things at hand: ${atHand().join(', ') || 'none'}`;
+        for (const effect of effects) {
+            if (effect.kind === 'object.update') {
+                const object = state.objects[effect.objectId];
+                if (object && object.id !== job.concerns && object.placeId !== placeId && !heldHere(object.holderId)) {
+                    failures.push(elsewhere(object));
+                    refused.add(effect);
+                }
+                // A thing may be put down here, or thrown or pushed next door, but not sent further.
+                else if (effect.placeId !== null && effect.placeId !== placeId && !state.places[placeId].connections.includes(effect.placeId)) {
+                    failures.push(`${object?.name ?? effect.objectId} can only go to ${state.places[placeId].name}, where this happens, or next door`);
+                    refused.add(effect);
+                }
+            }
+            const entityId = effect.kind === 'entity.condition' || effect.kind === 'property.set' || effect.kind === 'relation.set' || effect.kind === 'entity.move' ? effect.entityId : null;
+            const entity = entityId === null ? undefined : state.entities[entityId];
+            if (entity && entity.id !== job.concerns && entity.placeId !== null && entity.placeId !== placeId) {
+                failures.push(elsewhere(entity));
+                refused.add(effect);
+            }
+        }
+        // A change that restates a thing as it already is changes nothing: it is left out, not refused.
+        const restated = new Set();
+        for (const [id, changed] of objectChanges) {
+            const original = state.objects[id];
+            if (changed.placeId === original.placeId && changed.holderId === original.holderId
+                && changed.ownerId === original.ownerId && changed.condition === original.condition) {
+                for (const effect of effects)
+                    if (effect.kind === 'object.update' && effect.objectId === id)
+                        restated.add(effect);
+            }
+        }
+        for (const effect of effects) {
+            if (effect.kind === 'property.set' && state.entities[effect.entityId]?.properties[effect.propertyId]?.value === effect.value)
+                restated.add(effect);
+            if (effect.kind === 'relation.set' && state.entities[effect.entityId]?.relations[effect.relationId]?.targetId === effect.targetId)
+                restated.add(effect);
+        }
+        for (let index = effects.length - 1; index >= 0; index -= 1)
+            if (restated.has(effects[index]))
+                effects.splice(index, 1);
+        // Only the player's own act writes or signs a paper in the player's name; restating one as it already is writes nothing.
+        if (job.actorId !== state.playerId) {
+            const player = state.people[state.playerId].name;
+            const writer = job.actorId === null ? 'A happening' : state.people[job.actorId].name;
+            for (const effect of effects) {
+                const inPlayerName = effect.kind === 'entity.create' ? effect.initialProperties?.author === state.playerId
+                    : effect.kind === 'property.set' && (effect.propertyId === 'author' && effect.value === state.playerId
+                        || effect.propertyId === 'signed' && effect.value === true && state.entities[effect.entityId]?.properties.author?.value === state.playerId);
+                if (!inPlayerName)
+                    continue;
+                failures.push(`${writer} writes or signs nothing in ${player}'s name; only ${player}'s own act does. Hand on a paper that already exists, or name its real writer`);
+                refused.add(effect);
+            }
+        }
+        const objectiveEffectKinds = new Set([
+            'entity.create', 'property.set', 'relation.set', 'move', 'take', 'drop', 'object.update', 'entity.move', 'entity.condition',
+            'place.create', 'person.create', 'money', 'transfer', 'hold', 'role', 'incapacitate', 'request.open',
+        ]);
+        for (const effect of effects)
+            if (effect.kind === 'request.open' && effect.senderId !== job.actorId) {
+                failures.push('request sender must be the actor');
+            }
+        if (ruling.kindFit === 'complete' && (ruling.outcome === 'succeeded' || ruling.outcome === 'partial')
+            && !effects.some(effect => objectiveEffectKinds.has(effect.kind)) && restated.size === 0
+            && ruling.settledTensionId === null && ruling.newTension === null) {
+            failures.push('stateKindFit complete needs an objective typed change, such as entity.create or property.set; if nothing lasting changed, answer not-needed');
+        }
+        if (ruling.newKind !== null && !state.kinds[ruling.newKind.id]) {
+            effects.push({ kind: 'kind.request', request: ruling.newKind });
+        }
+        const normViolations = job.actorId !== null && ruling.actionKind !== null && ruling.outcome !== 'impossible'
+            ? normViolationsFor(state, job.actorId, placeId, ruling.actionKind) : [];
+        effects.push(...normViolations);
+        const importance = Math.max(ruling.importance, importanceFloorForEffects(state, effects), normViolations.length > 0 ? SHOCK_IMPORTANCE : 1);
+        if (ruling.settledTensionId !== null) {
+            const tension = state.tensions.find(candidate => candidate.id === ruling.settledTensionId && candidate.status === 'open');
+            if (!tension)
+                failures.push(`settledTensionId ${ruling.settledTensionId} is not an open tension`);
+            else
+                effects.push({ kind: 'tension.update', tensionId: tension.id, status: 'settled', note: (ruling.settlement ?? ruling.narration).slice(0, 2000) });
+        }
+        // A change the world's own data makes is made once, however the ruling restates it.
+        if (job.rulingEffects) {
+            const ruled = job.rulingEffects(state, ruling);
+            for (let index = effects.length - 1; index >= 0; index -= 1)
+                if (ruled.some(own => isDeepStrictEqual(own, effects[index])))
+                    effects.splice(index, 1);
+            effects.push(...ruled);
+        }
+        if (ruling.newTension !== null) {
+            const tensionId = `tension-${seq}`;
+            effects.push({ kind: 'tension.create', tensionId, title: ruling.newTension.title.slice(0, 200), summary: ruling.newTension.summary.slice(0, 2000), participantIds: ruling.newTension.participantIds.filter(id => state.people[id]),
+                openedBy: ruling.record.slice(0, MAX_LINE) });
+            // The model cannot name an id the engine has not minted yet, so its flag stands in for one.
+            if (ruling.newTension.visible && !ruling.visibleTensionIds.includes(tensionId))
+                ruling.visibleTensionIds.push(tensionId);
+        }
+        const sensory = signalNotice(state, effects, ruling.observed) ?? (ruling.signalChannel === null ? null
+            : `${SIGNAL_NOTICES[ruling.signalChannel]} from ${state.places[placeId].name}.`);
+        const affectedPlaces = new Set(effects.flatMap(effect => effect.kind === 'place.condition' ? [effect.placeId] : []));
+        const reach = job.reach ? job.reach.reach : ruling.reach === 'here' || sensory === null ? 'here'
+            : ruling.reach === 'everywhere' && affectedPlaces.size > 1 ? 'everywhere' : 'nearby';
+        const notice = job.reach ? job.reach.notice ?? sensory ?? `Something happens at ${state.places[placeId].name}.` : reach === 'here' ? null : sensory;
+        const known = (ids) => ids.filter(id => state.entities[id] !== undefined || state.objects[id] !== undefined);
+        const draft = session.draft({
+            kind: job.kind, actorId: job.actorId, placeId: placeId,
+            summary: job.summary(ruling).slice(0, 2000),
+            observed: ruling.observed ?? `${job.actorId ? state.people[job.actorId].name : 'Something'} acts in ${state.places[placeId].name}.`,
+            perceivedBy: perceivers,
+            visibleObjectIds: ruling.visibleObjectIds,
+            visibleTensionIds: ruling.visibleTensionIds,
+            ...(state.engine >= THING_MEMORY_ENGINE && known(ruling.thingIds).length > 0 ? { thingIds: known(ruling.thingIds) } : {}),
+            narration: ruling.narration, outcome: ruling.outcome, minutes: ruling.minutes, effects: [...extra, ...effects], causeSeq: job.causeSeq, importance, suggestions: [],
+            reach, notice,
+        });
+        if (job.kind === 'attempt' && importance >= SHOCK_IMPORTANCE && ruling.outcome !== 'impossible') {
+            draft.effects = [...draft.effects, ...seriousConsequences(state, { actorId: job.actorId, placeId, seq, minutes: ruling.minutes, record: ruling.record,
+                    observed: ruling.observed, reactorIds: ruling.reactorIds, perceivers, effects, notice, nearbyIds: draft.nearbyIds })];
+        }
+        const repeated = job.repeats?.(ruling);
+        if (repeated)
+            failures.push(repeated);
+        if (failures.length === 0) {
+            try {
+                const proposed = applyLivingEvent(state, draft);
+                for (const effect of effects) {
+                    if (effect.kind !== 'entity.create')
+                        continue;
+                    const entity = proposed.entities[effect.entityId];
+                    const missing = proposed.kinds[entity.kindId].properties
+                        .filter(property => property.requiredOnCreate && !entity.properties[property.id])
+                        .map(property => property.id);
+                    if (missing.length > 0)
+                        failures.push(`New ${entity.kindId} needs ${missing.join(', ')} before this act ends`);
+                }
+                for (const effect of draft.effects) {
+                    if (effect.kind !== 'incapacitate')
+                        continue;
+                    if (!blockedByGate(proposed, effect.personId, 'incapacitate')
+                        || blockedByGate(state, effect.personId, 'incapacitate')) {
+                        failures.push('incapacitate needs a newly active typed gate on that person');
+                    }
+                }
+            }
+            catch (error) {
+                failures.push(error instanceof Error ? error.message : String(error));
+            }
+        }
+        let dropped = 0;
+        if (failures.length > 0) {
+            session.rejectLast('effects-invalid');
+            extraRepair = job.kind === 'attempt' && errors.length > 0 && !isDeepStrictEqual(errors, failures);
+            const retrying = round === 0 || (round === 1 && extraRepair && session.canSpend());
+            // A happening the world wrote happens even when some of its changes cannot be made: its last
+            // ruling keeps what the world accepts, and counts what it leaves out.
+            const kept = job.kind === 'world' && !retrying ? acceptedPart(state, draft, extra, effects.filter(effect => effect.kind !== 'kind.request' && !refused.has(effect))) : null;
+            if (kept === null) {
+                // Each repair hears every mistake so far, so fixing one does not bring back another.
+                errors = [...new Set([...errors, ...failures])];
+                continue;
+            }
+            dropped = ruling.effects.length - kept.length;
+            draft.effects = [...extra, ...kept];
+            draft.perceivedBy = [...new Set(perceivers)].filter(id => witnesses.includes(id));
+            if (dropped > 0)
+                draft.droppedEffects = dropped;
+        }
+        // In a live world a long act only begins now. Its ruling is held, and what it tells and changes
+        // applies when its time has passed; those present see it begin.
+        if (job.attempt !== undefined && !job.finishing && job.actorId !== null && session.live() && ruling.minutes > LONG_ACT_MINUTES
+            && (ruling.outcome === 'succeeded' || ruling.outcome === 'partial')) {
+            const actor = state.people[job.actorId];
+            const { seq: _seq, at: _at, witnessIds: _witnesses, nearbyIds: _nearby, ...fields } = draft;
+            // What the act leaves for others to decide is worked out when it ends, from who is there then.
+            const held = { fields: { ...fields, effects }, record: ruling.record,
+                standing: Object.fromEntries(referencedIds(job.actorId, ruling).filter(id => state.people[id] || state.objects[id] || state.entities[id])
+                    .map(id => [id, standing(state, id)])), reactorIds: ruling.reactorIds.filter(id => state.people[id]) };
+            session.commit({
+                kind: 'attempt', actorId: job.actorId, placeId, summary: `${actor.name} begins: "${job.attempt}"`.slice(0, 2000),
+                narration: actor.isPlayer ? `You begin: ${job.attempt}`.slice(0, 2000) : null, observed: draft.observed, perceivedBy: perceivers, visibleObjectIds: [], visibleTensionIds: [],
+                outcome: null, minutes: ruling.minutes, causeSeq: job.causeSeq, importance: 2, suggestions: [], reach: 'here', notice: null,
+                effects: [...extra, { kind: 'schedule', scheduledId: `finish-${seq}`, personId: null, inMinutes: ruling.minutes, intent: state.engine >= FULL_SCHEDULE_INTENT_ENGINE ? job.attempt : job.attempt.slice(0, MAX_LINE),
+                        placeId, targetId: job.actorId, scheduleKind: 'finish', held }],
+            });
+            return;
+        }
+        const event = session.commit(draft);
+        const trigger = job.trigger(ruling);
+        const reactorIds = ruling.reactorIds.filter(id => perceivers.includes(id) && presentCharacters(session.state, placeId, job.actorId).includes(id)).slice(0, MAX_REACTORS);
+        await react(session, reactorIds, event, trigger, 'reaction', true);
+        await reactNearby(session, event);
+        return;
+    }
+    throw new LivingWorldError('inference-invalid', `The Game Master proposed changes the world cannot accept: ${errors.join('; ')}`);
+}
+// The changes of a ruling the world accepts, one at a time in order: each must apply after those kept
+// before it and change something. Null when even the ruling's own bookkeeping does not apply.
+function acceptedPart(state, draft, extra, effects) {
+    const applies = (list) => {
+        try {
+            return applyLivingEvent(state, { ...draft, effects: [...extra, ...list] });
+        }
+        catch (error) {
+            if (error instanceof LivingWorldError)
+                return null;
+            throw error;
+        }
+    };
+    if (applies([]) === null)
+        return null;
+    const kept = [];
+    for (const effect of effects) {
+        if (effect.kind === 'property.set' && state.entities[effect.entityId]?.properties[effect.propertyId]?.value === effect.value)
+            continue;
+        if (effect.kind === 'relation.set' && state.entities[effect.entityId]?.relations[effect.relationId]?.targetId === effect.targetId)
+            continue;
+        const next = applies([...kept, effect]);
+        if (next === null)
+            continue;
+        if (effect.kind === 'entity.create' && next.kinds[next.entities[effect.entityId].kindId].properties
+            .some(property => property.requiredOnCreate && !next.entities[effect.entityId].properties[property.id]))
+            continue;
+        kept.push(effect);
+    }
+    return kept;
+}
+// Where a person or thing is and what state it is in, as far as a ruling about it depends on it.
+function standing(state, id) {
+    const person = state.people[id];
+    if (person)
+        return `person ${person.placeId} ${person.incapacitated} ${person.held?.byId ?? ''} ${person.held ? 'held' : ''}`;
+    const object = state.objects[id];
+    if (object)
+        return `object ${object.placeId} ${object.holderId} ${object.condition}`;
+    const entity = state.entities[id];
+    if (entity)
+        return `entity ${entity.placeId} ${entity.holderId ?? ''} ${entity.condition ?? ''} ${Math.max(entity.introducedSeq, ...Object.values(entity.properties).map(slot => slot.changedSeq), ...Object.values(entity.relations).map(slot => slot.changedSeq))}`;
+    return 'absent';
+}
+// What a serious act leaves behind: a later look at its consequences unless the ruling already set
+// one, and a decision for each witness and for those who noticed it nearby, a few minutes apart.
+function seriousConsequences(state, act) {
+    const out = [];
+    const worldFollowups = act.effects.filter((effect) => effect.kind === 'schedule' && effect.personId === null);
+    if (!worldFollowups.some(effect => effect.inMinutes >= act.minutes + 30)) {
+        const later = worldFollowups.length > 0;
+        out.push({ kind: 'schedule', scheduledId: `aftermath-${act.seq}`, personId: null, inMinutes: act.minutes + (later ? 45 : 15),
+            intent: `${later ? 'Check lasting consequences' : 'Check what has changed'} after this serious event: ${act.record}`.slice(0, 600),
+            placeId: act.placeId, targetId: null, scheduleKind: 'world' });
+    }
+    const present = presentCharacters(state, act.placeId, act.actorId).filter(id => act.perceivers.includes(id));
+    const witnesses = [...new Set([...act.reactorIds, ...present])].filter(id => present.includes(id)).slice(0, MAX_REACTORS);
+    witnesses.forEach((id, index) => {
+        out.push(...shockPlanEffects(state, id, generatedId(state.engine, 'shock', [act.seq, id]), `Decide what to do about what you observed: ${act.observed}`.slice(0, 600), act.minutes + SHOCK_PLAN_DELAY_MINUTES + 5 * index, act.actorId));
+    });
+    if (act.notice !== null) {
+        out.push(...act.nearbyIds.filter(id => state.people[id] && !state.people[id].isPlayer && !state.people[id].incapacitated && !state.people[id].away && !state.people[id].departed).slice(0, MAX_REACTORS)
+            .flatMap((id, index) => shockPlanEffects(state, id, generatedId(state.engine, 'nearby-shock', [act.seq, id]), `Decide what to do about what you noticed: ${act.notice}`.slice(0, 600), act.minutes + SHOCK_PLAN_DELAY_MINUTES + 5 * index, null)));
+    }
+    return out;
+}
+// The people and things a ruling names: its actor, who perceives it or reacts, and what it changes.
+function referencedIds(actorId, ruling) {
+    const ids = new Set([...(actorId === null ? [] : [actorId]), ...(ruling.perceivedBy ?? []), ...ruling.reactorIds, ...ruling.visibleObjectIds]);
+    for (const effect of ruling.effects) {
+        for (const value of [effect.personId, effect.targetId, effect.objectId, effect.entityId])
+            if (typeof value === 'string')
+                ids.add(value);
+    }
+    return [...ids].sort();
+}
+// How a person or thing a held act names stands now, described for the Game Master.
+function nowStanding(state, id) {
+    const person = state.people[id];
+    const object = state.objects[id];
+    if (person)
+        return person.incapacitated ? `${person.name} can no longer act` : `${person.name} is now at ${state.places[person.placeId]?.name ?? person.placeId}`;
+    if (object)
+        return `${object.name} is now ${object.holderId ? `held by ${personLabel(state, object.holderId)}` : `at ${state.places[object.placeId ?? '']?.name ?? 'an unknown place'}`}, ${object.condition}`;
+    return `${state.entities[id]?.name ?? id} has changed`;
+}
+// The people and things a ruling names whose place or state changed between two states, described for the Game Master.
+function changedReferences(before, after, actorId, ruling) {
+    const changed = [];
+    for (const id of referencedIds(actorId, ruling)) {
+        if (standing(before, id) === standing(after, id))
+            continue;
+        const person = after.people[id];
+        const object = after.objects[id];
+        if (person)
+            changed.push(person.incapacitated && !before.people[id]?.incapacitated ? `${person.name} can no longer act`
+                : `${person.name} is now at ${after.places[person.placeId]?.name ?? person.placeId}`);
+        else if (object)
+            changed.push(`${object.name} is now ${object.holderId ? `held by ${personLabel(after, object.holderId)}` : `at ${after.places[object.placeId ?? '']?.name ?? 'an unknown place'}`}, ${object.condition}`);
+        else
+            changed.push(`${after.entities[id]?.name ?? id} has changed`);
+    }
+    return changed;
+}
+function anonymousCreation(effect) {
+    switch (effect.kind) {
+        case 'entity.create': return effect.entityId === null || effect.entityId === undefined;
+        case 'object.create': return effect.objectId === null;
+        case 'place.create': return effect.placeId === null;
+        case 'person.create': return effect.personId === null;
+        case 'tension.create': return effect.tensionId === null;
+        default: return false;
+    }
+}
+function createdIdentity(effect) {
+    switch (effect.kind) {
+        case 'entity.create': return effect.entityId;
+        case 'object.create': return effect.objectId;
+        case 'place.create': return effect.placeId;
+        case 'person.create': return effect.personId;
+        case 'tension.create': return effect.tensionId;
+        default: return null;
+    }
+}
+// Someone in a connected room who noticed the event may come to look, call out, or carry on.
+async function reactNearby(session, event) {
+    if (event.nearbyIds.length === 0 || !session.canSpendOptional())
+        return;
+    const state = session.state;
+    const candidates = event.nearbyIds.filter(id => state.people[id] && !state.people[id].isPlayer && !state.people[id].incapacitated);
+    if (candidates.length === 0)
+        return;
+    const closeness = (id) => {
+        const relationship = event.actorId ? state.people[id].relationships[event.actorId] : undefined;
+        return relationship ? Math.abs(relationship.trust) + Math.abs(relationship.warmth) : 0;
+    };
+    // Someone the event brings into a person's room is seen arriving; that person does not hear a commotion.
+    const arriving = candidates.filter(id => arrivalFor(state, event, id) !== null);
+    const [chosen] = [...(arriving.length > 0 ? arriving : candidates)].sort((a, b) => closeness(b) - closeness(a) || a.localeCompare(b));
+    const arrival = arrivalFor(state, event, chosen);
+    const mover = event.effects.find(effect => effect.kind === 'move' && effect.placeId === state.people[chosen].placeId && effect.personId !== chosen);
+    if (arrival !== null && mover?.kind === 'move') {
+        await react(session, [chosen], event, { kind: 'arrive', actorId: mover.personId, text: `${arrival}.`, narration: null }, 'reaction', true);
+        return;
+    }
+    const from = event.placeId ? state.places[event.placeId]?.name ?? null : null;
+    await react(session, [chosen], event, { kind: 'nearby', actorId: null, text: event.notice ?? 'a commotion', narration: null, noticedFrom: from }, 'reaction', true);
+}
+function uniqueIds(values) {
+    return [...new Set(values.filter((id) => typeof id === 'string'))];
+}
+function parseRuling(answer) {
+    const value = answer;
+    const outcomes = ['succeeded', 'partial', 'failed', 'impossible'];
+    if (!value || typeof value !== 'object' || typeof value.narration !== 'string' || value.narration.trim() === '' || typeof value.outcome !== 'string' || !outcomes.includes(value.outcome) || !Array.isArray(value.stateUpdates ?? value.effects)) {
+        throw new LivingWorldError('inference-invalid', 'The Game Master answer is malformed');
+    }
+    // Answers recorded before engine 25 name the same fields effects, kindFit and newKind.
+    const updates = (value.stateUpdates ?? value.effects);
+    const newKind = value.stateNewKind === undefined ? value.newKind : value.stateNewKind;
+    const kindFit = value.stateKindFit ?? value.kindFit;
+    const newTension = value.newTension && typeof value.newTension === 'object' ? value.newTension : null;
+    const narration = value.narration.trim().slice(0, 900);
+    return {
+        narration,
+        record: (typeof value.record === 'string' && value.record.trim() !== '' ? value.record.trim() : narration).slice(0, 600),
+        observed: typeof value.observed === 'string' && value.observed.trim() !== '' ? value.observed.trim().slice(0, 600) : null,
+        // Naming the same person or thing twice in these lists says nothing more, so each is kept once.
+        perceivedBy: Array.isArray(value.perceivedBy) ? uniqueIds(value.perceivedBy) : null,
+        visibleObjectIds: Array.isArray(value.visibleObjectIds) ? uniqueIds(value.visibleObjectIds) : [],
+        // Ids of things here; the list names no enum, so as not to grow with the room, and unknown ids are dropped.
+        thingIds: Array.isArray(value.thingIds) ? uniqueIds(value.thingIds).slice(0, 8) : [],
+        visibleTensionIds: Array.isArray(value.visibleTensionIds) ? uniqueIds(value.visibleTensionIds) : [],
+        outcome: value.outcome,
+        minutes: clampInt(value.minutes, 0, 240, 5),
+        importance: clampInt(value.importance, 1, 10, 4),
+        reach: value.reach === 'nearby' || value.reach === 'everywhere' ? value.reach : 'here',
+        signalChannel: typeof value.signalChannel === 'string' && SIGNAL_SENSES.includes(value.signalChannel) ? value.signalChannel : null,
+        effects: updates.map(flattenShape).filter((effect) => effect !== null && typeof effect === 'object' && typeof effect.kind === 'string').slice(0, 8)
+            .map(normalizeGmEffect),
+        reactorIds: Array.isArray(value.reactorIds) ? value.reactorIds.filter((id) => typeof id === 'string') : [],
+        settledTensionId: typeof value.settledTensionId === 'string' ? value.settledTensionId : null,
+        settlement: typeof value.settlement === 'string' ? value.settlement : null,
+        newTension: newTension && typeof newTension.title === 'string' && typeof newTension.summary === 'string'
+            ? { title: newTension.title, summary: newTension.summary, participantIds: Array.isArray(newTension.participantIds) ? newTension.participantIds.filter((id) => typeof id === 'string') : [], visible: newTension.visible === true }
+            : null,
+        newKind: kindRequestSchema.safeParse(newKind).success ? kindRequestSchema.parse(newKind) : null,
+        kindFit: kindFit === 'complete' || kindFit === 'missing' ? kindFit : 'not-needed',
+        actionKind: typeof value.actionKind === 'string' && /^[a-z0-9][a-z0-9-]{0,63}$/u.test(value.actionKind) ? value.actionKind : null,
+    };
+}
+// A change arrives as { kind, values }; answers recorded before engine 26 are already flat.
+function flattenShape(change) {
+    if (change === null || typeof change !== 'object' || Array.isArray(change))
+        return change;
+    const { values, ...rest } = change;
+    return values !== null && typeof values === 'object' && !Array.isArray(values) ? { ...values, ...rest } : change;
+}
+function normalizeGmEffect(effect) {
+    return {
+        kind: effect.kind,
+        personId: effect.personId ?? null, targetId: effect.targetId ?? null, sourcePersonId: effect.sourcePersonId ?? null, placeId: effect.placeId ?? null,
+        objectId: effect.objectId ?? null, tensionId: effect.tensionId ?? null, name: effect.name ?? null,
+        text: effect.text ?? null, condition: effect.condition ?? null, role: effect.role ?? null, amount: effect.amount ?? null,
+        trust: effect.trust ?? null, warmth: effect.warmth ?? null, minutes: effect.minutes ?? null,
+        connections: effect.connections ?? null, participantIds: effect.participantIds ?? null,
+        status: effect.status ?? null, entityId: effect.entityId ?? null, kindId: effect.kindId ?? null,
+        propertyId: effect.propertyId ?? null, relationId: effect.relationId ?? null, roleId: effect.roleId ?? null,
+        priorId: effect.priorId ?? null, value: effect.value ?? null, choice: effect.choice ?? null,
+        ...(effect.initialProperties ? { initialProperties: effect.initialProperties } : {}),
+    };
+}
+const need = (value, field, kind) => {
+    if (typeof value !== 'string' || value.trim() === '')
+        throw new Error(`${kind} needs ${field}`);
+    return value.trim();
+};
+// The longest role a newcomer may be given: a few words.
+// The side of a thing's condition a change is to, by the name the thing shows for it; none means its state.
+const side = (name) => {
+    const aspect = name?.trim().slice(0, 40);
+    return aspect ? { aspect } : {};
+};
+// The Game Master fills one flat record per effect. This maps it onto the typed
+// vocabulary, or explains exactly what was missing so the next round can fix it.
+export function translateGmEffect(state, record, seq, index, placeId = null, usedCreationIds = new Set()) {
+    try {
+        const playerId = state.playerId;
+        const fresh = (kind) => `${kind}-${seq}-${index + 1}`;
+        const occupied = (id) => usedCreationIds.has(id) || Boolean(state.entities[id] || state.objects[id]
+            || state.people[id] || state.places[id] || state.tensions.some(tension => tension.id === id));
+        const newId = (kind, proposed) => {
+            if (proposed !== null && /^[a-z0-9][a-z0-9-]{0,63}$/u.test(proposed) && !occupied(proposed))
+                return proposed;
+            const base = fresh(kind);
+            let id = base;
+            for (let suffix = 2; occupied(id); suffix += 1)
+                id = `${base}-${suffix}`;
+            return id;
+        };
+        let effect;
+        switch (record.kind) {
+            case 'move':
+                effect = { kind: 'move', personId: need(record.personId, 'personId', 'move'), placeId: need(record.placeId, 'placeId', 'move') };
+                break;
+            case 'object.update': {
+                const id = need(record.objectId, 'objectId', 'object.update');
+                // A written thing or token: a holder or a place moves it; otherwise its visible condition changes.
+                if (state.entities[id]) {
+                    if (record.targetId !== null)
+                        effect = { kind: 'entity.move', entityId: id, holderId: record.targetId, placeId: null };
+                    else if (record.placeId !== null)
+                        effect = { kind: 'entity.move', entityId: id, holderId: null, placeId: record.placeId };
+                    else if (record.condition !== null)
+                        effect = { kind: 'entity.condition', entityId: id, condition: record.condition.slice(0, 200), ...side(record.name) };
+                    else
+                        throw new Error(`${state.entities[id].name} needs a condition, a holder or a place`);
+                }
+                else
+                    effect = { kind: 'object.update', objectId: id, condition: record.condition, ...(record.condition === null ? {} : side(record.name)), placeId: record.targetId === null ? record.placeId : null, holderId: record.targetId, ownerId: record.personId };
+                break;
+            }
+            // A written thing or token that is somewhere changes hands the same way an object does.
+            case 'take': {
+                const id = need(record.objectId, 'objectId', 'take');
+                effect = state.entities[id] ? { kind: 'entity.move', entityId: id, holderId: need(record.personId, 'personId', 'take'), placeId: null }
+                    : { kind: 'object.update', objectId: id, condition: null, placeId: null, holderId: need(record.personId, 'personId', 'take'), ownerId: null };
+                break;
+            }
+            case 'drop': {
+                const id = need(record.objectId, 'objectId', 'drop');
+                const to = record.placeId ?? placeId;
+                if (to === null)
+                    throw new Error('drop needs a placeId');
+                effect = state.entities[id] ? { kind: 'entity.move', entityId: id, holderId: null, placeId: to }
+                    : { kind: 'object.update', objectId: id, condition: null, placeId: to, holderId: null, ownerId: null };
+                break;
+            }
+            case 'object.create':
+                effect = { kind: 'object.create', objectId: newId('object', record.objectId), name: need(record.name, 'name', 'object.create'), summary: need(record.text, 'text', 'object.create'), placeId: record.targetId === null ? record.placeId : null, holderId: record.targetId, ownerId: record.personId, condition: record.condition ?? 'intact' };
+                break;
+            case 'place.condition': {
+                const placeId = need(record.placeId, 'placeId', 'place.condition');
+                const aspect = record.name ?? fresh('aspect');
+                effect = { kind: 'place.condition', placeId, add: record.text, remove: null, aspect };
+                if (effect.add === null && !state.places[placeId]?.conditionAspects[aspect])
+                    throw new Error('place.condition needs a current aspect id to resolve');
+                break;
+            }
+            case 'place.create':
+                effect = { kind: 'place.create', placeId: newId('place', record.placeId), name: need(record.name, 'name', 'place.create'), summary: need(record.text, 'text', 'place.create'), connections: record.connections ?? [] };
+                break;
+            case 'person.create': {
+                // Someone already in the story is never brought in a second time, under their id or their name.
+                const name = need(record.name, 'name', 'person.create');
+                const same = (record.personId ? state.people[record.personId] : undefined)
+                    ?? Object.values(state.people).find(person => person.departed === undefined && person.name === name);
+                if (same)
+                    throw new Error(`${same.name} (${same.id}) is already in the story${same.isPlayer ? ' as the player' : same.away ? ', away for now' : `, in ${state.places[same.placeId]?.name ?? same.placeId}`}; bring in someone new or no one`);
+                // A newcomer knows only what they see and are told here, never what the referee knows about them.
+                // Their role is said once, beside their name; when they came is kept as a time, not as words that age.
+                const role = record.role ?? 'Newcomer';
+                // A role is what anyone could call them in a few words, not where they stand or what they hold.
+                if (role.length > MAX_ROLE)
+                    throw new Error(`${need(record.name, 'name', 'person.create')}'s role is a few words, such as "courier" or "site visitor"; say where they stand in the narration`);
+                const at = need(record.placeId, 'placeId', 'person.create');
+                // They come with an aim of their own, which is their first goal; their voice is not their job title.
+                const wants = record.text?.trim() ? record.text.trim().slice(0, MAX_LINE) : null;
+                if (wants === null)
+                    throw new Error('person.create needs text: what brought them here and what they want now');
+                effect = { kind: 'person.create', personId: newId('person', record.personId), name: need(record.name, 'name', 'person.create'), role,
+                    summary: `First seen at ${state.places[at]?.name ?? at}.`, persona: 'Decide from what you see and are told, and from what brought you here.', placeId: at, pronouns: null, wants };
+                break;
+            }
+            case 'person.leave':
+                effect = { kind: 'person.leave', personId: need(record.personId, 'personId', 'person.leave'), reason: need(record.text, 'text', 'person.leave').slice(0, 600) };
+                break;
+            case 'person.away':
+                effect = { kind: 'person.away', personId: need(record.personId, 'personId', 'person.away'),
+                    minutes: Math.max(AWAY_MINUTES.min, Math.min(AWAY_MINUTES.max, record.minutes ?? AWAY_MINUTES.min)), reason: need(record.text, 'text', 'person.away').slice(0, 600) };
+                break;
+            case 'money':
+                effect = { kind: 'money', personId: need(record.personId, 'personId', 'money'), delta: record.amount ?? 0 };
+                if (effect.delta === 0)
+                    throw new Error('money needs a non-zero amount');
+                break;
+            case 'transfer': {
+                const amount = record.amount ?? 0;
+                if (!(amount > 0))
+                    throw new Error('transfer needs a positive amount');
+                effect = { kind: 'transfer', fromId: record.personId?.trim() || null, toId: record.targetId?.trim() || null, amount: Math.round(amount * 100) / 100 };
+                break;
+            }
+            case 'relationship':
+                effect = { kind: 'relationship', personId: need(record.personId, 'personId', 'relationship'), targetId: need(record.targetId, 'targetId', 'relationship'), trust: record.trust ?? 0, warmth: record.warmth ?? 0, note: '' };
+                if (effect.personId === playerId)
+                    throw new Error('The player decides their own feelings');
+                break;
+            case 'belief':
+                effect = { kind: 'belief', personId: need(record.personId, 'personId', 'belief'), subject: need(record.name, 'name', 'belief'), claim: need(record.text, 'text', 'belief'), sourcePersonId: null,
+                    evidence: { kind: 'inferred', eventSeq: seq, sourceId: null } };
+                if (effect.personId === playerId)
+                    throw new Error('The player forms their own beliefs');
+                break;
+            case 'commitment':
+                effect = { kind: 'commitment', commitmentId: fresh('commitment'), personId: need(record.personId, 'personId', 'commitment'), toId: need(record.targetId, 'targetId', 'commitment'), text: need(record.text, 'text', 'commitment'), dueInMinutes: record.minutes };
+                break;
+            case 'goal':
+                effect = { kind: 'goal', personId: need(record.personId, 'personId', 'goal'), add: record.text, dropGoalId: record.name };
+                if (effect.add === null && effect.dropGoalId === null)
+                    throw new Error('goal needs text or a goal id');
+                if (effect.personId === playerId)
+                    throw new Error('The player chooses their own goals');
+                break;
+            case 'mood':
+                effect = { kind: 'mood', personId: need(record.personId, 'personId', 'mood'), mood: cleanMood(record.text, '') };
+                if (effect.mood === '')
+                    throw new Error('mood needs a word or two of text');
+                break;
+            case 'hold':
+                effect = { kind: 'hold', personId: need(record.personId, 'personId', 'hold'), byId: record.targetId, reason: record.text?.trim() ? record.text.trim().slice(0, 600) : null };
+                break;
+            case 'role':
+                effect = { kind: 'role', personId: need(record.personId, 'personId', 'role'), role: need(record.text, 'text', 'role').slice(0, 200), roleId: record.roleId ?? null };
+                break;
+            case 'person.condition':
+                effect = { kind: 'person.condition', personId: need(record.personId, 'personId', 'person.condition'), condition: record.text?.trim() ? record.text.trim().slice(0, 200) : null };
+                break;
+            case 'schedule': {
+                if (record.personId !== null && record.personId.trim() !== '')
+                    throw new Error('A character must choose their own plan; schedule only a world happening');
+                effect = { kind: 'schedule', scheduledId: fresh('world'), personId: null, inMinutes: Math.max(1, record.minutes ?? 30), intent: need(record.text, 'text', 'schedule'), placeId: record.placeId ?? placeId, targetId: record.targetId, scheduleKind: 'world' };
+                if (effect.placeId === null)
+                    throw new Error('a world happening needs a placeId');
+                break;
+            }
+            case 'fact': {
+                const aspect = record.name ?? fresh('aspect');
+                effect = { kind: 'fact', add: record.text, remove: null, aspect };
+                if (effect.add === null && !state.factAspects[aspect])
+                    throw new Error('fact needs a current aspect id to resolve');
+                break;
+            }
+            case 'tension.update':
+                effect = { kind: 'tension.update', tensionId: need(record.tensionId, 'tensionId', 'tension.update'), status: record.status ?? 'open', note: record.text };
+                break;
+            case 'tension.create':
+                effect = { kind: 'tension.create', tensionId: newId('tension', record.tensionId), title: need(record.name, 'name', 'tension.create'), summary: need(record.text, 'text', 'tension.create'), participantIds: (record.participantIds ?? []).filter(id => state.people[id]) };
+                break;
+            case 'incapacitate':
+                effect = { kind: 'incapacitate', personId: need(record.personId, 'personId', 'incapacitate'), reason: need(record.text, 'text', 'incapacitate') };
+                break;
+            case 'message': {
+                const message = { fromId: need(record.personId, 'personId', 'message'), toIds: [need(record.targetId, 'targetId', 'message')], text: need(record.text, 'text', 'message') };
+                if (message.fromId === playerId)
+                    throw new Error('The world never speaks for the player');
+                effect = state.messageTravel ? dispatch(seq, index + 1, { ...message, replies: false, sourcePersonId: record.sourcePersonId })
+                    : { kind: 'message', ...message, ...(record.sourcePersonId ? { sourcePersonId: record.sourcePersonId } : {}) };
+                break;
+            }
+            case 'entity.create': {
+                const proposedId = need(record.entityId, 'entityId', 'entity.create');
+                // Making again a thing that is right here would make a second copy of it; an id taken by a
+                // thing elsewhere is only a clash of names, and the new thing gets its own id.
+                const existing = state.entities[proposedId] ?? state.objects[proposedId];
+                const atHand = existing !== undefined && placeId !== null && (existing.placeId === placeId
+                    || existing.holderId !== null && state.people[existing.holderId]?.placeId === placeId);
+                if (existing && atHand)
+                    throw new Error(`${proposedId} already exists as ${existing.name}: change it, or leave it`);
+                effect = { kind: 'entity.create', entityId: newId('entity', proposedId),
+                    // A thing made into someone's hand is where they stand, whatever place the ruling named.
+                    kindId: need(record.kindId, 'kindId', 'entity.create'), name: need(record.name, 'name', 'entity.create'),
+                    placeId: record.placeId ?? (record.personId && state.people[record.personId] ? state.people[record.personId].placeId : null),
+                    ...(record.initialProperties ? { initialProperties: record.initialProperties } : {}),
+                    ...(record.condition?.trim() ? { condition: record.condition.trim().slice(0, 200) } : {}), ...(record.personId ? { holderId: record.personId } : {}),
+                    ...(record.kindId === 'decision' && record.participantIds?.length ? { memberIds: record.participantIds } : {}) };
+                break;
+            }
+            case 'ballot': {
+                if (record.choice !== 'yes' && record.choice !== 'no' && record.choice !== 'abstain')
+                    throw new Error('ballot needs choice');
+                effect = { kind: 'ballot', entityId: need(record.entityId, 'entityId', 'ballot'), personId: need(record.personId, 'personId', 'ballot'), choice: record.choice };
+                break;
+            }
+            case 'property.set':
+                effect = { kind: 'property.set', entityId: need(record.entityId, 'entityId', 'property.set'), propertyId: need(record.propertyId, 'propertyId', 'property.set'), value: record.value ?? null };
+                break;
+            case 'relation.set':
+                effect = { kind: 'relation.set', entityId: need(record.entityId, 'entityId', 'relation.set'), relationId: need(record.relationId, 'relationId', 'relation.set'), targetId: record.targetId };
+                break;
+            case 'request.open': {
+                const senderId = need(record.personId, 'personId', 'request.open');
+                const receiverId = need(record.targetId, 'targetId', 'request.open');
+                if (record.priorId) {
+                    const prior = state.requests.find(request => request.id === record.priorId);
+                    if (!prior || prior.senderId !== senderId || prior.receiverId !== receiverId) {
+                        throw new Error(`Unknown request ${record.priorId} for this sender and receiver`);
+                    }
+                    throw new Error(`Request ${prior.id} was already made; its status is ${prior.status}`);
+                }
+                effect = { kind: 'request.open', requestId: fresh('request'), senderId, receiverId,
+                    topic: need(record.text, 'text', 'request.open') };
+                break;
+            }
+            default: throw new Error(`Unknown effect kind ${String(record.kind)}`);
+        }
+        if (effect.kind === 'object.update' && effect.holderId !== null
+            && effect.holderId !== state.objects[effect.objectId]?.holderId
+            && state.objects[effect.objectId]?.singlePersonMovable === false) {
+            throw new Error(`${state.objects[effect.objectId].name} cannot be carried by one person; make the part that moves a new thing, or leave it where it is`);
+        }
+        const moving = effect.kind === 'object.update' && effect.holderId !== null ? { thing: state.objects[effect.objectId], holderId: effect.holderId }
+            : effect.kind === 'entity.move' && effect.holderId !== null ? { thing: state.entities[effect.entityId], holderId: effect.holderId } : null;
+        if (moving?.thing) {
+            const holder = state.people[moving.holderId];
+            // A held object has no place of its own; a held typed thing is where its holder is.
+            const fromPlace = moving.thing.placeId ?? (moving.thing.holderId ? state.people[moving.thing.holderId]?.placeId : null);
+            if (holder && fromPlace && fromPlace !== holder.placeId) {
+                // The repair hears where the thing is and what is within reach, so it can choose again.
+                const atHand = [...Object.values(state.objects).filter(candidate => candidate.placeId === holder.placeId
+                        || (candidate.holderId !== null && state.people[candidate.holderId]?.placeId === holder.placeId)).map(candidate => candidate.name),
+                    ...(state.entityPlaceIds[holder.placeId] ?? []).map(id => state.entities[id].name)];
+                throw new Error(`${moving.thing.name} is in ${state.places[fromPlace]?.name ?? fromPlace}, not with ${holder.name} in ${state.places[holder.placeId]?.name ?? holder.placeId}; `
+                    + (atHand.length > 0 ? `things at hand there: ${atHand.join(', ')}` : 'there is nothing here to hand over'));
+            }
+        }
+        const parsed = effectSchema.safeParse(effect);
+        if (!parsed.success)
+            throw new Error(`${record.kind}: ${parsed.error.issues.map(issue => `${issue.path.join('.')} ${issue.message}`).join(', ')}`);
+        return { effect: parsed.data };
+    }
+    catch (error) {
+        return { error: error instanceof Error ? error.message : String(error) };
+    }
+}
+// A vote a character casts in their own answer, on a decision open to them.
+function parseBallot(value) {
+    const ballot = value && typeof value === 'object' ? value : null;
+    return ballot && typeof ballot.decisionId === 'string' && (ballot.choice === 'yes' || ballot.choice === 'no' || ballot.choice === 'abstain')
+        ? { decisionId: ballot.decisionId, choice: ballot.choice } : null;
+}
+// Whether this person already said these very words in a talk still under way; no one says a line twice.
+// An ask still open may be recalled to the one asked once two game hours have passed since it was made
+// or last recalled; a sooner repeat, or one after a refusal, is held back.
+function reminderDue(state, request, personId, targetId) {
+    if (!request || state.engine < REMINDER_ENGINE || request.status !== 'open' || request.senderId !== personId || request.receiverId !== targetId)
+        return false;
+    const last = request.remindedAt ?? request.openedAt;
+    return last !== undefined && state.clock - last >= REMINDER_MINUTES;
+}
+function saidAlready(state, personId, text) {
+    return state.conversations.some(conversation => conversation.endedAt === null && conversation.lines.some(line => line.speakerId === personId && line.text === text));
+}
+// The ballot effect for a vote this person may cast now, among the votes the moment concerns, or none.
+function ballotEffects(state, personId, ballot, concerned) {
+    const decision = ballot && (concerned === 'any' || concerned.has(ballot.decisionId)) ? state.entities[ballot.decisionId] : undefined;
+    return ballot && decision?.members?.includes(personId) && decision.ballots?.[personId] === undefined && votingShut(state, decision, state.clock) === null
+        ? [{ kind: 'ballot', entityId: decision.id, personId, choice: ballot.choice }] : [];
+}
+// Each reactor answers once; an answer that repeats itself or leaves English goes back
+// once with the reason. When the reaction is optional, a silent model means a silent
+// witness; the event it answers is already saved.
+async function react(session, reactorIds, cause, trigger, phase, optional) {
+    // People answer one after another, so each hears what those before them said.
+    let acted = false;
+    for (const id of reactorIds) {
+        const decidedIn = session.state.people[id]?.placeId;
+        const release = await session.takeTurn(id);
+        let reaction = null;
+        try {
+            // Someone who walked off, went home or left while an earlier decision of theirs was out answers this moment no more.
+            if (decidedIn !== undefined && isHere(session.state, id, decidedIn))
+                reaction = await reactAndRecord(session, id, cause, trigger, phase, optional);
+        }
+        finally {
+            release();
+        }
+        if (reaction === null)
+            continue;
+        // One witness per moment may step in physically; the world resolves what they try, in the room it was
+        // decided in: someone who has walked out does not do it elsewhere. An act made in answer to an act
+        // draws words, not another act, so two people do not trade acts without end.
+        if (reaction.act && !acted && session.answeringActs === 0 && session.canSpendOptional() && !session.state.people[id].incapacitated && !session.state.people[id].held
+            && isHere(session.state, id, decidedIn)
+            && blockedByGate(session.state, id, 'act') === null) {
+            acted = true;
+            session.answeringActs += 1;
+            try {
+                await adjudicate(session, id, reaction.act);
+            }
+            catch (error) {
+                if (!(error instanceof LivingWorldError) || (error.code !== 'inference-invalid' && error.code !== 'inference-unavailable'))
+                    throw error;
+            }
+            finally {
+                session.answeringActs -= 1;
+            }
+        }
+    }
+}
+// One person's reaction, decided and recorded; null when they decide nothing.
+async function reactAndRecord(session, id, cause, trigger, phase, optional) {
+    const { reaction: decided, dropped, asked } = await decideReaction(session, id, cause, trigger, phase, optional);
+    if (!decided)
+        return null;
+    // Words decided while this person said something else meanwhile, or before someone came into or
+    // left their room, answer a moment that has passed.
+    const place = session.state.people[id]?.placeId;
+    const later = session.state.events.filter(event => event.seq > asked);
+    const roomChanged = later.some(event => event.effects.some(effect => effect.kind === 'move' && effect.personId !== id
+        && (effect.placeId === place || event.placeId === place)));
+    const movedOn = decided.say !== null && (roomChanged || later.some(event => event.actorId === id
+        && event.effects.some(effect => effect.kind === 'say' || effect.kind === 'message' || effect.kind === 'dispatch')));
+    const reaction = movedOn ? { ...decided, say: null, request: null } : decided;
+    const fields = reactionFields(session.state, id, reaction, cause, trigger, dropped + (movedOn ? 1 : 0));
+    if (fields)
+        session.commit(fields);
+    return reaction;
+}
+async function decideReaction(session, id, cause, trigger, phase, optional) {
+    if (optional && !session.canSpendOptional())
+        return { reaction: null, dropped: 0, asked: session.state.revision };
+    let errors = [];
+    let last = null;
+    let asked = session.state.revision;
+    for (let round = 0; round < 2; round += 1) {
+        if (round > 0 && !(optional ? session.canSpendOptional() : session.canSpend()))
+            break;
+        try {
+            // Each try reads the world as it is when it goes; another event may have landed while the last one was out.
+            const build = (focusIds = []) => {
+                const state = session.state;
+                asked = state.revision;
+                const input = characterReactionInput(state, state.people[id], { ...trigger, thingIds: cause.thingIds ?? [] }, true, errors, focusIds);
+                return { input, responseSchema: scopedReactionResponseSchema(input) };
+            };
+            const answer = await session.complete({ role: 'character', phase, system: CHARACTER_REACTION_SYSTEM, ...build(), ...LIVING_INFERENCE_LIMITS[phase] }, id, cause.seq, build);
+            const reaction = parseReaction(answer);
+            const problems = reactionProblems(reaction, session.state, id);
+            if (problems.length === 0)
+                return { reaction, dropped: 0, asked };
+            last = reaction;
+            // Asking again what was already asked is left unsaid below. Someone spoken to is asked once more,
+            // so they still answer; a reaction nobody asked for is not worth a second call.
+            if (phase === 'reaction' && problems.every(problem => typeof problem !== 'string' && problem.kind === 'request-already-made'))
+                break;
+            session.rejectLast('reaction-rejected');
+            errors = problems;
+        }
+        catch (error) {
+            if (error instanceof LivingWorldError && error.code === 'inference-invalid') {
+                errors = [error.message];
+                continue;
+            }
+            if (optional && error instanceof LivingWorldError && error.code === 'inference-unavailable')
+                return { reaction: null, dropped: 0, asked };
+            throw error;
+        }
+    }
+    // What still fails its checks is left out, and the event records how much was left out: a line that
+    // re-asks a known request, or a decision on a request this person cannot decide.
+    if (last === null)
+        return { reaction: null, dropped: 0, asked };
+    const reasking = last.request?.priorId !== undefined && last.request.priorId !== null
+        && reactionProblems({ ...last, requestDecision: null }, session.state, id).length > 0;
+    const undecidable = last.requestDecision !== null && reactionProblems({ ...last, request: null }, session.state, id).length > 0;
+    const kept = { ...last, ...(reasking ? { say: null, request: null } : {}), ...(undecidable ? { requestDecision: null } : {}) };
+    return { reaction: kept, dropped: (reasking && last.say !== null ? 1 : 0) + (undecidable ? 1 : 0), asked };
+}
+function reactionProblems(reaction, state, personId) {
+    const problems = [];
+    if (reaction.request?.priorId) {
+        const prior = state.requests.find(request => request.id === reaction.request.priorId);
+        if (!prior)
+            problems.push({ kind: 'unknown-request', requestId: reaction.request.priorId, status: null });
+        else if (prior.receiverId === reaction.request.receiverId && !reminderDue(state, prior, personId, reaction.request.receiverId)) {
+            problems.push({ kind: 'request-already-made', requestId: prior.id, status: prior.status });
+        }
+    }
+    if (reaction.requestDecision) {
+        const request = state.requests.find(item => item.id === reaction.requestDecision.id);
+        if (!request || request.receiverId !== personId || request.status !== 'open') {
+            problems.push({ kind: 'request-not-open', requestId: reaction.requestDecision.id, status: request?.status ?? null });
+        }
+    }
+    return problems;
+}
+function parsePlanValue(value, fallbackMinutes) {
+    const plan = value && typeof value === 'object' ? value : null;
+    if (!plan || typeof plan.intent !== 'string' || plan.intent.trim() === '')
+        return null;
+    // A line too short to show anything is no description of what the person is doing.
+    // The model names it seenDoing; older answers and stand-ins may still call it doing or seen.
+    const shown = typeof plan.seenDoing === 'string' ? plan.seenDoing : typeof plan.doing === 'string' ? plan.doing : plan.seen;
+    const seen = typeof shown === 'string' && shown.trim().length >= MIN_SEEN_LENGTH ? shown.trim().slice(0, 200) : null;
+    return { intent: plan.intent.trim().slice(0, 300), ...(seen === null ? {} : { seen }), placeId: typeof plan.placeId === 'string' ? plan.placeId : null,
+        targetId: typeof plan.targetId === 'string' ? plan.targetId : null, inMinutes: clampInt(plan.inMinutes, 1, 100_000, fallbackMinutes) };
+}
+function parseReaction(answer) {
+    const value = answer;
+    if (!value || typeof value !== 'object' || typeof value.mood !== 'string')
+        throw new LivingWorldError('inference-invalid', 'The character answer is malformed');
+    const commitment = value.commitment && typeof value.commitment === 'object' ? value.commitment : null;
+    const belief = value.belief && typeof value.belief === 'object' ? value.belief : null;
+    const tell = value.tell && typeof value.tell === 'object' ? value.tell : null;
+    const request = value.request && typeof value.request === 'object' ? value.request : null;
+    const requestDecision = value.requestDecision && typeof value.requestDecision === 'object' ? value.requestDecision : null;
+    return {
+        say: typeof value.say === 'string' && value.say.trim() !== '' ? value.say.trim().slice(0, MAX_SPOKEN) : null,
+        request: request && typeof request.topic === 'string' && request.topic.trim() !== '' && typeof request.receiverId === 'string'
+            ? { topic: request.topic.trim().slice(0, 600), receiverId: request.receiverId,
+                priorId: typeof request.priorId === 'string' ? request.priorId : null } : null,
+        requestDecision: requestDecision && typeof requestDecision.id === 'string'
+            && (requestDecision.status === 'answered' || requestDecision.status === 'refused' || requestDecision.status === 'done')
+            ? { id: requestDecision.id, status: requestDecision.status } : null,
+        answered: typeof value.answered === 'string' ? value.answered : null,
+        act: typeof value.act === 'string' && value.act.trim() !== '' ? value.act.trim().slice(0, 200) : null,
+        toIds: Array.isArray(value.toIds) ? value.toIds.filter((id) => typeof id === 'string').slice(0, 4) : [],
+        mood: cleanMood(value.mood, 'Present'),
+        leaveToPlaceId: typeof value.leaveToPlaceId === 'string' ? value.leaveToPlaceId : null,
+        trust: clampInt(value.trust, -20, 20, 0),
+        warmth: clampInt(value.warmth, -20, 20, 0),
+        relationshipNote: typeof value.relationshipNote === 'string' && value.relationshipNote.trim() !== '' ? value.relationshipNote.trim().slice(0, 200) : null,
+        belief: belief && typeof belief.subject === 'string' && typeof belief.claim === 'string' && belief.subject.trim() !== '' && belief.claim.trim() !== '' ? { subject: belief.subject.trim().slice(0, 120), claim: belief.claim.trim().slice(0, 300) } : null,
+        commitment: commitment && typeof commitment.toId === 'string' && typeof commitment.text === 'string' && commitment.text.trim() !== '' ? { toId: commitment.toId, text: commitment.text.trim().slice(0, 300), dueInMinutes: typeof commitment.dueInMinutes === 'number' ? clampInt(commitment.dueInMinutes, 0, 100_000, 0) : null,
+            placeId: typeof commitment.placeId === 'string' && commitment.placeId.trim() !== '' ? commitment.placeId : null } : null,
+        newGoal: typeof value.newGoal === 'string' && value.newGoal.trim() !== '' ? value.newGoal.trim().slice(0, 300) : null,
+        goalDone: typeof value.goalDone === 'string' && value.goalDone.trim() !== '' ? value.goalDone.trim().slice(0, 300) : null,
+        weight: clampInt(value.weight, 1, 10, 3),
+        stance: value.stance === 'undecided' || value.stance === 'cooperate' || value.stance === 'refuse'
+            || value.stance === 'report' || value.stance === 'avoid' || value.stance === 'confront' ? value.stance : null,
+        plan: parsePlanValue(value.plan, 30),
+        ballot: parseBallot(value.ballot),
+        tell: tell && typeof tell.targetId === 'string' && typeof tell.text === 'string' && tell.text.trim() !== '' ? { targetId: tell.targetId, text: tell.text.trim().slice(0, 300) } : null,
+        suggestedReplies: Array.isArray(value.suggestedReplies) ? value.suggestedReplies.filter((item) => typeof item === 'string' && item.trim() !== '').map(item => item.trim().slice(0, 120)).slice(0, 3) : [],
+        endConversation: value.endConversation === true,
+    };
+}
+// A character's reaction may only change the character: their words, feelings, beliefs,
+// promises, plans, errands, and where they go. The reducer still checks each effect.
+function reactionFields(state, personId, reaction, cause, trigger, dropped = 0) {
+    const person = state.people[personId];
+    // Someone who went home or left while deciding says and does nothing here.
+    if (person.away || person.departed)
+        return null;
+    const actorId = trigger.actorId;
+    const present = new Set(peopleAt(state, person.placeId));
+    const effects = [];
+    const toIds = reaction.toIds.filter(id => present.has(id) && id !== personId);
+    const addressed = toIds.length > 0 ? toIds : actorId !== null && present.has(actorId) && actorId !== personId ? [actorId] : [];
+    const prior = reaction.request?.priorId ? state.requests.find(request => request.id === reaction.request.priorId) : null;
+    const repeated = prior?.senderId === personId && prior.receiverId === reaction.request?.receiverId && !reminderDue(state, prior, personId, reaction.request?.receiverId);
+    const reminding = prior?.senderId === personId && !repeated && reminderDue(state, prior, personId, reaction.request?.receiverId);
+    // Words only for people who have left this person's last lines unanswered are left unsaid.
+    const unheard = addressed.length > 0 && addressed.every(id => unansweredSince(state, personId, id) !== null);
+    const again = reaction.say !== null && saidAlready(state, personId, reaction.say);
+    if ((unheard || again) && reaction.say !== null)
+        dropped += 1;
+    const say = repeated || unheard || again || blockedByGate(state, personId, 'speak') !== null ? null : reaction.say;
+    if (say !== null)
+        effects.push({ kind: 'say', personId, text: say, toIds: addressed });
+    if (say !== null && reminding && prior && addressed.includes(prior.receiverId))
+        effects.push({ kind: 'request.remind', requestId: prior.id });
+    if (say !== null && reaction.request && !repeated && !reminding && addressed.includes(reaction.request.receiverId)) {
+        effects.push({ kind: 'request.open', requestId: generatedId(state.engine, 'request', [cause.seq, personId]), senderId: personId,
+            receiverId: reaction.request.receiverId, topic: reaction.request.topic });
+    }
+    if (reaction.requestDecision)
+        effects.push({ kind: 'request.update', requestId: reaction.requestDecision.id,
+            status: reaction.requestDecision.status });
+    const voted = ballotEffects(state, personId, reaction.ballot, new Set(cause.thingIds ?? []));
+    effects.push(...voted);
+    // Someone who hears their own question answered keeps it settled, with the words that settled it.
+    const asked = reaction.answered ? state.requests.find(request => request.id === reaction.answered) : undefined;
+    if (asked && asked.senderId === personId && asked.receiverId === actorId && asked.status === 'open' && trigger.kind === 'speech') {
+        effects.push({ kind: 'request.update', requestId: asked.id, status: 'answered', answer: trigger.text.slice(0, 2000) });
+    }
+    const mood = reaction.mood;
+    if (mood !== person.mood)
+        effects.push({ kind: 'mood', personId, mood });
+    const target = actorId !== null && actorId !== personId && state.people[actorId] ? actorId : null;
+    if (target && reaction.stance !== null && (cause.perceivedBy ?? cause.witnessIds).includes(personId)) {
+        effects.push({ kind: 'stance', personId, actorId: target, status: reaction.stance, sourceSeq: cause.seq });
+    }
+    if (target && (reaction.trust !== 0 || reaction.warmth !== 0)) {
+        effects.push({ kind: 'relationship', personId, targetId: target, trust: reaction.trust, warmth: reaction.warmth, note: '' });
+    }
+    // What someone did is witnessed; only what someone said is taken on their word.
+    const toldBy = trigger.kind === 'speech' || trigger.kind === 'message' ? target : null;
+    if (reaction.belief && trigger.kind !== 'nearby')
+        effects.push({ kind: 'belief', personId,
+            subject: reaction.belief.subject, claim: reaction.belief.claim, sourcePersonId: toldBy,
+            evidence: { kind: toldBy ? 'told' : 'inferred', eventSeq: cause.seq, sourceId: toldBy } });
+    if (reaction.commitment && state.people[reaction.commitment.toId] && reaction.commitment.toId !== personId) {
+        const where = reaction.commitment.placeId !== null && state.places[reaction.commitment.placeId] ? { placeId: reaction.commitment.placeId } : {};
+        effects.push({ kind: 'commitment', commitmentId: generatedId(state.engine, 'commitment', [cause.seq, personId]), personId, toId: reaction.commitment.toId, text: reaction.commitment.text, dueInMinutes: reaction.commitment.dueInMinutes, ...where });
+    }
+    const done = reaction.goalDone ? person.goals.find(goal => goal.status === 'active' && goal.id === reaction.goalDone) : undefined;
+    if (reaction.newGoal || done)
+        effects.push({ kind: 'goal', personId, add: reaction.newGoal, dropGoalId: null, doneGoalId: done?.id ?? null });
+    // Words can be a shock too: a threat, an insult or an advance said out loud weighs on the listener and gets a decision later.
+    const relationshipRupture = (trigger.kind === 'speech' || trigger.kind === 'message') && (reaction.trust <= -5 || reaction.warmth <= -5);
+    const assessedSpeech = trigger.kind === 'speech' && cause.importance >= SHOCK_IMPORTANCE;
+    // Only a moment ruled serious, or one that breaks this person's trust or warmth, gives them a decision
+    // to make later; how heavily they weigh an ordinary line does not.
+    const shocked = assessedSpeech || relationshipRupture && cause.importance < SHOCK_IMPORTANCE;
+    if (shocked) {
+        if (!assessedSpeech && (cause.perceivedBy ?? cause.witnessIds).includes(personId))
+            effects.push({ kind: 'memory', personId,
+                text: cause.observed ?? cause.summary, importance: Math.max(reaction.weight, SHOCK_IMPORTANCE), participantIds: cause.witnessIds.filter(id => id !== personId) });
+    }
+    if (reaction.plan && (reaction.plan.placeId === null || state.places[reaction.plan.placeId]) && (reaction.plan.targetId === null || state.people[reaction.plan.targetId])) {
+        // Restating a pending plan for the same place and person does not put it off.
+        const pending = person.plan;
+        const restated = pending !== null && (pending.placeId !== null || pending.targetId !== null)
+            && pending.placeId === reaction.plan.placeId && pending.targetId === reaction.plan.targetId
+            && pending.dueAt > state.clock && pending.dueAt < state.clock + reaction.plan.inMinutes;
+        // The plan's id comes from the reaction's own event, so it never repeats an earlier plan's.
+        effects.push(...planEffects(state, personId, restated ? { ...reaction.plan, inMinutes: pending.dueAt - state.clock } : reaction.plan, state.revision + 1));
+    }
+    if (shocked && !state.schedule.some(item => item.personId === personId && isDecision(item) && item.at <= state.clock + SHOCK_PLAN_DELAY_MINUTES)) {
+        effects.push({ kind: 'schedule', scheduledId: generatedId(state.engine, 'shock', [cause.seq, personId]), personId, inMinutes: SHOCK_PLAN_DELAY_MINUTES, intent: `${say === null ? 'Decide what to do about this' : 'Decide what to do now, beyond what you said, about this'}: ${observedSummary(cause, personId) ?? cause.observed ?? 'what just happened'}`.slice(0, 600), placeId: null, targetId: target, scheduleKind: 'plan', importance: SHOCK_IMPORTANCE });
+    }
+    // Passing news on: said now to someone here, sent to an absent player, or carried as an errand to an absent character.
+    const told = [];
+    const tellTarget = reaction.tell && reaction.tell.targetId !== personId && reaction.tell.targetId !== actorId ? state.people[reaction.tell.targetId] : undefined;
+    // A gate on speech stops a tell by mouth and the errand that would carry it; a gate on messages stops it by message.
+    const gaggedSpeech = blockedByGate(state, personId, 'speak') !== null;
+    const gaggedMessage = blockedByGate(state, personId, 'message') !== null;
+    const tellHere = tellTarget !== undefined && isHere(state, tellTarget.id, person.placeId);
+    const tellBlocked = tellTarget !== undefined && (tellHere ? gaggedSpeech : tellTarget.isPlayer ? gaggedMessage : gaggedSpeech);
+    // Someone away is told nothing by mouth until they are back.
+    if (reaction.tell && tellTarget && !tellTarget.incapacitated && !tellBlocked && (tellHere || tellTarget.isPlayer || tellTarget.away === undefined)) {
+        if (tellHere) {
+            if (say === null || !addressed.includes(tellTarget.id)) {
+                effects.push({ kind: 'say', personId, text: reaction.tell.text, toIds: [tellTarget.id] });
+                told.push(tellTarget.name);
+            }
+        }
+        else if (tellTarget.isPlayer) {
+            effects.push(state.messageTravel ? dispatch(state.revision + 1, 0, { fromId: personId, toIds: [tellTarget.id], text: reaction.tell.text, replies: false })
+                : { kind: 'message', fromId: personId, toIds: [tellTarget.id], text: reaction.tell.text });
+            told.push(tellTarget.name);
+        }
+        else if (!state.schedule.some(item => item.personId === personId && item.kind === 'errand')) {
+            effects.push({ kind: 'schedule', scheduledId: generatedId(state.engine, 'errand', [cause.seq, personId]), personId, inMinutes: ERRAND_DELAY_MINUTES, intent: reaction.tell.text, placeId: null, targetId: tellTarget.id, scheduleKind: 'errand' });
+        }
+    }
+    if (reaction.endConversation && say === null) {
+        const conversation = state.conversations.find(candidate => candidate.endedAt === null && candidate.placeId === person.placeId && candidate.participantIds.includes(personId));
+        if (conversation)
+            effects.push({ kind: 'conversation.end', conversationId: conversation.id });
+    }
+    let minutes = say === null && told.length === 0 ? 0 : SPEECH_MINUTES;
+    const way = reaction.leaveToPlaceId !== null && reaction.leaveToPlaceId !== person.placeId ? travelPath(state, person.placeId, reaction.leaveToPlaceId) : null;
+    const leaving = !heldHere(state, personId) && !blockedByGate(state, personId, 'move') && way !== null;
+    if (leaving) {
+        effects.push({ kind: 'move', personId, placeId: reaction.leaveToPlaceId });
+        minutes += TRAVEL_MINUTES_PER_HOP;
+    }
+    // A reaction whose every change was left out still leaves a quiet record of how much was left out.
+    const holdsBack = (count) => count === 0 ? null : {
+        kind: 'reaction', actorId: personId, placeId: person.placeId, summary: `${person.name} holds back`.slice(0, 2000), narration: null, outcome: null,
+        minutes: 0, effects: [], causeSeq: cause.seq, importance: 1, suggestions: [], ...quiet, droppedEffects: count,
+    };
+    if (effects.length === 0)
+        return holdsBack(dropped);
+    // A reaction with nothing said, told or done is inward: its record keeps the mood, and nobody sees it.
+    const spoken = [
+        ...(say === null ? [] : [`says: "${say}"`]),
+        ...(told.length === 0 ? [] : [`tells ${told.join(', ')}: "${reaction.tell.text}"`]),
+    ];
+    const outward = [...spoken, ...voted.map(effect => effect.kind === 'ballot' ? `votes ${effect.choice} on ${state.entities[effect.entityId].name}` : ''),
+        ...(leaving ? [`leaves for ${state.places[reaction.leaveToPlaceId].name}`] : [])];
+    const fields = {
+        kind: 'reaction', actorId: personId, placeId: person.placeId,
+        summary: `${person.name} ${outward.length > 0 ? outward.join(' and ') : `reacts (${mood})`}`.slice(0, 2000), narration: null, outcome: null, minutes, effects,
+        ...(outward.length > 0 ? {} : { perceivedBy: [] }),
+        // Onlookers see only the first room they head for, not where they are going.
+        ...(leaving ? { observed: `${person.name} ${[...spoken, `leaves toward ${firstRoom(state, way)}`].join(' and ')}`.slice(0, 2000) } : {}),
+        causeSeq: cause.seq, importance: Math.max(2, Math.min(10, Math.max(cause.importance - 1, reaction.weight - 1))),
+        suggestions: addressed.includes(state.playerId) ? reaction.suggestedReplies : [], ...quiet,
+        ...(dropped > 0 ? { droppedEffects: dropped } : {}),
+    };
+    try {
+        applyLivingEvent(state, { seq: state.revision + 1, at: state.clock, witnessIds: witnessesFor(state, fields), nearbyIds: nearbyFor(state, fields), ...fields });
+        return fields;
+    }
+    catch (error) {
+        if (!(error instanceof LivingWorldError))
+            throw error;
+        // Keep what the reducer accepts: the spoken line and the mood, and record what was left out.
+        const safe = effects.filter(effect => effect.kind === 'say' || effect.kind === 'mood');
+        const { perceivedBy: _inward, observed: _leaving, ...outwardFields } = fields;
+        return safe.length === 0 ? holdsBack(dropped + effects.length) : { ...outwardFields, effects: safe, minutes: say === null ? 0 : SPEECH_MINUTES,
+            summary: (say === null ? `${person.name} reacts (${mood})` : `${person.name} says: "${say}"`).slice(0, 2000),
+            ...(say === null ? { perceivedBy: [] } : {}), ...(dropped + effects.length - safe.length > 0 ? { droppedEffects: dropped + effects.length - safe.length } : {}) };
+    }
+}
+// What onlookers see of someone setting off is the first room on their way, never where or why they go;
+// the player's map keeps the same room as where they were last seen heading.
+function firstRoom(state, path) {
+    const next = path[1] ?? path[0];
+    return state.places[next]?.name ?? next;
+}
+// A pending decision about someone's serious act is a plan item that carries that person's id and
+// the act's importance. Routine plans replace one another but never a pending decision.
+// A decision is a plan at shock importance about who acted, or a shock decision whose actor the
+// person cannot know. Routine plans are scheduled at routine importance.
+function isDecision(item) {
+    return item.kind === 'plan' && item.importance >= SHOCK_IMPORTANCE
+        && (item.targetId !== null || item.id.startsWith('nearby-shock-') || item.id.startsWith('shock-') || item.id.startsWith('vote-'));
+}
+function planEffects(state, personId, plan, seq, suffix = '') {
+    const existing = state.schedule.filter(item => item.personId === personId && item.kind === 'plan' && !isDecision(item));
+    return [
+        ...existing.map((item) => ({ kind: 'unschedule', scheduledId: item.id })),
+        { kind: 'plan', personId, plan: { intent: plan.intent, ...(plan.seen ? { seen: plan.seen } : {}), placeId: plan.placeId, targetId: plan.targetId, dueAt: state.clock + plan.inMinutes } },
+        { kind: 'schedule', scheduledId: generatedId(state.engine, 'plan', [seq, personId, suffix], `plan-${seq}-${personId}${suffix}`, true), personId, inMinutes: plan.inMinutes, intent: plan.intent, placeId: plan.placeId, targetId: plan.targetId, scheduleKind: 'plan', importance: ROUTINE_PLAN_IMPORTANCE,
+            ...(state.engine >= BOUNDED_IDENTIFIERS_ENGINE && suffix === '-again' ? { replanned: true } : {}) },
+    ];
+}
+// A shock sets routine business aside: the witness decides about it a few minutes later.
+function shockPlanEffects(state, personId, scheduledId, intent, inMinutes, actorId) {
+    const urgent = state.schedule.find(item => item.personId === personId
+        && item.at <= state.clock + inMinutes && item.importance >= SHOCK_IMPORTANCE);
+    if (urgent)
+        return [];
+    return [
+        ...state.schedule.filter(item => item.personId === personId && item.kind === 'plan' && !isDecision(item)).map((item) => ({ kind: 'unschedule', scheduledId: item.id })),
+        { kind: 'plan', personId, plan: { intent, placeId: null, targetId: actorId, dueAt: state.clock + inMinutes } },
+        { kind: 'schedule', scheduledId, personId, inMinutes, intent, placeId: null, targetId: actorId, scheduleKind: 'plan', importance: SHOCK_IMPORTANCE },
+    ];
+}
+// Someone is here who is at the place and has neither left the story nor gone away.
+function isHere(state, personId, placeId) {
+    return peopleAt(state, placeId).includes(personId);
+}
+// When one character speaks to another, the listener answers once, if they heard it. Nobody answers an answer.
+async function replyBetween(session, speakerId, listenerId, cause, text) {
+    const listener = session.state.people[listenerId];
+    if (!listener || listener.isPlayer || listener.incapacitated || !cause.witnessIds.includes(listenerId)
+        || !isHere(session.state, listenerId, session.state.people[speakerId]?.placeId ?? ''))
+        return;
+    await react(session, [listenerId], cause, { kind: 'speech', actorId: speakerId, text, narration: null }, 'reply', true);
+}
+// ---- Scheduled activity -------------------------------------------------------
+async function settleDue(session) {
+    let handled = 0;
+    const attempted = new Set();
+    const recovered = new Set();
+    for (let items = 0; items < MAX_DUE_ITEMS_PER_STEP + MAX_DUE_ERRANDS_PER_STEP; items += 1) {
+        const state = session.state;
+        // The schedule is ordered by time, so the due items are its head.
+        const ready = [];
+        for (const list of [state.schedule, state.meterSchedule])
+            for (const item of list) {
+                if (item.at > state.clock)
+                    break;
+                if (!attempted.has(item.id) && predictionReady(state, item))
+                    ready.push(item);
+            }
+        ready.sort((left, right) => right.importance - left.importance || left.at - right.at || left.id.localeCompare(right.id));
+        // A person whose typed cause no longer holds recovers with an event where they are, whether or
+        // not anyone is with them; a command loads the surroundings of everyone who cannot act.
+        const recovering = Object.values(state.people).find(person => person.incapacitatedBy !== undefined && !recovered.has(person.id)
+            && blockedByGate(state, person.id, 'incapacitate') === null);
+        if (recovering) {
+            recovered.add(recovering.id);
+            session.commit({ kind: 'world', actorId: null, placeId: recovering.placeId, summary: `${recovering.name} can act again.`, narration: null, outcome: null, minutes: 0,
+                effects: [], causeSeq: null, importance: 2, suggestions: [], ...quiet });
+            continue;
+        }
+        const abandoned = ready.find(item => ownerCannotAct(state, item));
+        if (abandoned) {
+            abandon(session, abandoned);
+            continue;
+        }
+        const modelAllowed = handled < MAX_DUE_ITEMS_PER_STEP && session.canSpend();
+        const due = modelAllowed
+            ? handled === 0 ? ready.find(item => item.kind === 'world') ?? ready[0]
+                : ready.find(item => item.kind !== 'world') ?? ready.find(item => item.kind === 'world')
+            : ready.find(item => item.kind === 'arrive' || item.kind === 'errand' || item.kind === 'deliver' || item.kind === 'back' || item.kind === 'count');
+        if (!due)
+            break;
+        const needsModel = due.kind === 'reply' || due.kind === 'plan' || due.kind === 'world' || due.kind === 'finish';
+        if (needsModel)
+            handled += 1;
+        // An item the model could not answer stays due, but does not block other ready work.
+        if (!await dispatchItem(session, due))
+            attempted.add(due.id);
+    }
+}
+function ownerCannotAct(state, item) {
+    const owner = item.personId === null ? null : state.people[item.personId];
+    // Someone away decides nothing until they are back; a plan or errand that came due meanwhile is set aside.
+    return item.personId !== null && (!owner || owner.incapacitated || owner.isPlayer || owner.departed !== undefined
+        || owner.away !== undefined && (item.kind === 'plan' || item.kind === 'arrive' || item.kind === 'errand'));
+}
+// The event cites the complete scheduled intent by sourceSeq; only its display summary is shortened.
+function intentSummary(prefix, intent, suffix) {
+    const available = MAX_TEXT - prefix.length - suffix.length;
+    if (intent.length <= available)
+        return prefix + intent + suffix;
+    let excerpt = intent.slice(0, available - 1);
+    const last = excerpt.charCodeAt(excerpt.length - 1);
+    if (last >= 0xd800 && last <= 0xdbff)
+        excerpt = excerpt.slice(0, -1);
+    return prefix + excerpt + '…' + suffix;
+}
+function abandon(session, item) {
+    session.commit({ kind: 'plan', actorId: null, placeId: item.placeId, summary: intentSummary('The appointment to ', item.intent, ' cannot proceed because its owner cannot act.'),
+        narration: null, outcome: null, minutes: 0, effects: [{ kind: 'unschedule', scheduledId: item.id }], causeSeq: item.sourceSeq || null, importance: 2, suggestions: [], ...quiet });
+}
+function dispatchItem(session, due) {
+    switch (due.kind) {
+        case 'reply': return answerMessage(session, due);
+        case 'arrive': return arriveAndSpeak(session, due);
+        case 'errand': return runErrand(session, due);
+        case 'world': return worldFollowUp(session, due);
+        case 'plan': return carryOutPlan(session, due, true);
+        case 'deliver': return deliverMessage(session, due);
+        case 'finish': return finishAct(session, due);
+        case 'back': return comeBack(session, due);
+        case 'count': return countVote(session, due);
+    }
+}
+// A vote opens or is counted at its written time, with no model. Its opening gives each member who has
+// not voted a turn to decide; at its close the ballots cast decide the result. Both are news everywhere.
+async function countVote(session, due) {
+    const state = session.state;
+    const decision = due.count ? state.entities[due.count.entityId] : undefined;
+    const done = [{ kind: 'unschedule', scheduledId: due.id }];
+    const base = { actorId: null, placeId: decision?.placeId ?? due.placeId, narration: null, outcome: null, minutes: 0, causeSeq: due.sourceSeq || null, suggestions: [], ...quiet };
+    if (!decision || decision.members === undefined || decision.result !== undefined) {
+        session.commit({ kind: 'world', ...base, summary: intentSummary('', due.intent, ': nothing left to count.'), effects: done, importance: 1 });
+        return true;
+    }
+    if (due.count.opens) {
+        const question = String(decision.properties.question?.value ?? decision.name).slice(0, 300);
+        const voters = decision.members.map(id => state.people[id]).filter((person) => person !== undefined
+            && !person.isPlayer && person.departed === undefined && decision.ballots?.[person.id] === undefined);
+        session.commit({ kind: 'world', ...base, summary: `Voting opens on ${decision.name}.`, observed: `Voting opens on ${decision.name}.`, importance: 4,
+            reach: 'everywhere', notice: `Voting opens on ${decision.name}.`,
+            effects: [...done, ...voters.map((person, index) => ({ kind: 'schedule', scheduledId: generatedId(state.engine, 'vote', [state.revision + 1, person.id], `vote-${state.revision + 1}-${person.id}`.slice(0, 64)), personId: person.id,
+                    inMinutes: 1 + index, intent: `Cast your vote on ${decision.name}: ${question}`.slice(0, MAX_LINE), placeId: null, targetId: null, scheduleKind: 'plan', importance: PROMISE_IMPORTANCE }))] });
+        return true;
+    }
+    const result = countResult(decision);
+    session.commit({ kind: 'world', ...base, summary: `The votes on ${decision.name} are counted: ${result}.`, observed: `The votes on ${decision.name} are counted: ${result}.`, importance: 6,
+        reach: 'everywhere', notice: `The votes on ${decision.name} are counted: ${result}.`,
+        effects: [...done, { kind: 'decision.close', entityId: decision.id, result }] });
+    return true;
+}
+// Someone away comes back to where they left from when their time away is up; what to do next
+// they decide there.
+async function comeBack(session, due) {
+    const person = session.state.people[due.personId];
+    session.commit({ kind: 'move', actorId: person.id, placeId: person.placeId, summary: `${person.name} comes back`, narration: null, outcome: null, minutes: 0,
+        effects: [{ kind: 'unschedule', scheduledId: due.id }, ...(person.away ? [{ kind: 'person.back', personId: person.id }] : []), { kind: 'plan', personId: person.id, plan: null }],
+        causeSeq: due.sourceSeq || null, importance: 1, suggestions: [], ...quiet, observed: `${person.name} comes in.` });
+    return true;
+}
+async function settleItem(session, due) {
+    if (ownerCannotAct(session.state, due)) {
+        abandon(session, due);
+        return true;
+    }
+    return dispatchItem(session, due);
+}
+// A character who walked over to say something says it on arrival, no model needed.
+// If the person they came for has gone, they decide afresh a little later.
+async function arriveAndSpeak(session, due) {
+    const state = session.state;
+    const person = state.people[due.personId];
+    const target = due.targetId ? state.people[due.targetId] : undefined;
+    const cause = due.sourceSeq || null;
+    if (target && (unansweredSince(state, person.id, target.id) !== null || saidAlready(state, person.id, due.intent))) {
+        // Someone who has left this person's last lines unanswered, or already heard these words, is not told it again on arrival.
+        session.commit({
+            kind: 'plan', actorId: person.id, placeId: person.placeId, summary: `${person.name} leaves it unsaid: ${target.name} ${unansweredSince(state, person.id, target.id) !== null ? 'has not answered' : 'has heard it already'}`, narration: null, outcome: null, minutes: 0,
+            effects: [{ kind: 'unschedule', scheduledId: due.id }, ...(session.live() ? planEffects({ ...state, schedule: state.schedule.filter(item => item.id !== due.id) }, person.id, { intent: 'Carry on with the day', placeId: null, targetId: null, inMinutes: DEFAULT_ACTIVITY_MINUTES }, state.revision + 1) : [{ kind: 'plan', personId: person.id, plan: null }])],
+            causeSeq: cause, importance: 1, suggestions: [], ...quiet, droppedEffects: 1,
+        });
+        return true;
+    }
+    if (target && isHere(state, target.id, person.placeId) && !target.incapacitated && blockedByGate(state, person.id, 'speak') === null) {
+        const event = session.commit({
+            kind: 'reaction', actorId: person.id, placeId: person.placeId, summary: `${person.name} says to ${target.name}: "${due.intent}"`.slice(0, 2000), narration: null, outcome: null, minutes: SPEECH_MINUTES,
+            effects: [{ kind: 'unschedule', scheduledId: due.id }, { kind: 'say', personId: person.id, text: due.intent, toIds: [target.id] },
+                ...(session.live() ? planEffects({ ...state, schedule: state.schedule.filter(item => item.id !== due.id) }, person.id, { intent: `Talk with ${target.name}`, seen: `talking with ${target.name}`, placeId: null, targetId: target.id, inMinutes: DEFAULT_ACTIVITY_MINUTES }, state.revision + 1)
+                    : [{ kind: 'plan', personId: person.id, plan: null }])],
+            causeSeq: cause, importance: 3, suggestions: [], ...quiet,
+        });
+        await replyBetween(session, person.id, target.id, event, due.intent);
+        return true;
+    }
+    const seq = state.revision + 1;
+    session.commit({
+        kind: 'plan', actorId: person.id, placeId: person.placeId, summary: `${person.name} arrives, but ${target?.name ?? 'the person they came for'} is not here`, narration: null, outcome: null, minutes: 0,
+        effects: [{ kind: 'unschedule', scheduledId: due.id }, ...planEffects({ ...state, schedule: state.schedule.filter(item => item.id !== due.id) }, person.id, { intent: `Find ${target?.name ?? 'someone'} and say: ${due.intent}`.slice(0, 300), placeId: null, targetId: target?.id ?? null, inMinutes: 30 }, seq)],
+        causeSeq: cause, importance: 1, suggestions: [], ...quiet,
+    });
+    return true;
+}
+// An errand is a walk to tell someone something: no model, just feet and a sentence.
+async function runErrand(session, due) {
+    const state = session.state;
+    const person = state.people[due.personId];
+    const target = due.targetId ? state.people[due.targetId] : undefined;
+    const cause = due.sourceSeq || null;
+    const drop = (why) => session.commit({
+        kind: 'plan', actorId: person.id, placeId: person.placeId, summary: `${person.name} lets it go: ${why}`, narration: null, outcome: null, minutes: 0,
+        effects: [{ kind: 'unschedule', scheduledId: due.id }], causeSeq: cause, importance: 1, suggestions: [], ...quiet,
+    });
+    if (!target || target.incapacitated) {
+        drop(`${target?.name ?? 'the person'} cannot be told now`);
+        return true;
+    }
+    if (unansweredSince(state, person.id, target.id) !== null) {
+        drop(`${target.name} has not answered`);
+        return true;
+    }
+    if ((heldHere(state, person.id) || blockedByGate(state, person.id, 'move')) && target.placeId !== person.placeId) {
+        drop(`${person.name} cannot leave to find ${target.name}`);
+        return true;
+    }
+    if (blockedByGate(state, person.id, 'speak') !== null) {
+        drop(`${person.name} cannot speak now`);
+        return true;
+    }
+    if (isHere(state, target.id, person.placeId)) {
+        const event = session.commit({
+            kind: 'reaction', actorId: person.id, placeId: person.placeId, summary: `${person.name} says to ${target.name}: "${due.intent}"`.slice(0, 2000), narration: null, outcome: null, minutes: SPEECH_MINUTES,
+            effects: [{ kind: 'unschedule', scheduledId: due.id }, { kind: 'say', personId: person.id, text: due.intent, toIds: [target.id] }],
+            causeSeq: cause, importance: 3, suggestions: [], ...quiet,
+        });
+        await replyBetween(session, person.id, target.id, event, due.intent);
+        return true;
+    }
+    const path = travelPath(state, person.placeId, target.placeId);
+    if (!path) {
+        drop(`there is no way to reach ${target.name}`);
+        return true;
+    }
+    const seq = state.revision + 1;
+    session.commit({
+        kind: 'move', actorId: person.id, placeId: person.placeId, summary: `${person.name} travels to ${state.places[target.placeId].name} to find ${target.name}`, narration: null, outcome: null, minutes: (path.length - 1) * TRAVEL_MINUTES_PER_HOP,
+        observed: `${person.name} leaves toward ${firstRoom(state, path)}.`,
+        effects: [
+            { kind: 'unschedule', scheduledId: due.id },
+            { kind: 'move', personId: person.id, placeId: target.placeId },
+            // What to tell them is chosen on arrival, from what is there then.
+            ...planEffects({ ...state, schedule: state.schedule.filter(item => item.id !== due.id) }, person.id, { intent: `Tell ${target.name}: ${due.intent}`.slice(0, 300),
+                seen: `on the way to ${target.name}`, placeId: target.placeId, targetId: target.id, inMinutes: (path.length - 1) * TRAVEL_MINUTES_PER_HOP }, seq),
+        ],
+        causeSeq: cause, importance: 2, suggestions: [], ...quiet,
+    });
+    return true;
+}
+// A happening that comes back is set up again for its next written time as this one is settled,
+// however late this one is ruled; times missed meanwhile are skipped, not stacked.
+function nextTime(due) {
+    return (state) => {
+        if (due.everyMinutes === undefined)
+            return [];
+        const next = due.at + due.everyMinutes * Math.max(1, Math.floor((state.clock - due.at) / due.everyMinutes) + 1);
+        return [{ kind: 'schedule', scheduledId: generatedId(state.engine, 'repeat', [due.series ?? due.id, next], `${due.series ?? due.id}-${next}`.slice(0, 64), true),
+                personId: null, inMinutes: next - state.clock, intent: due.intent, placeId: due.placeId, targetId: due.targetId, scheduleKind: 'world', importance: due.importance,
+                everyMinutes: due.everyMinutes, series: due.series ?? due.id, ...(due.beat === undefined ? {} : { beat: due.beat }) }];
+    };
+}
+// The typed results a world's data gives one of its happenings, as far as the world can take them now:
+// facts that replace their aspect, a problem's new state, money that moves.
+function beatResults(state, placeId, beat) {
+    if (!beat?.then)
+        return [];
+    const tension = beat.then.tension ? state.tensions.find(candidate => candidate.id === beat.then.tension.id) : undefined;
+    const results = [
+        ...(beat.then.facts ?? []).map((fact) => ({ kind: 'fact', add: fact.text, remove: null, aspect: fact.aspect })),
+        ...(tension && beat.then.tension ? [{ kind: 'tension.update', tensionId: tension.id, status: beat.then.tension.status ?? tension.status, note: beat.then.tension.summary ?? null }] : []),
+        ...(beat.then.transfers ?? []).map((transfer) => ({ kind: 'transfer', ...transfer })),
+    ];
+    // Each result is kept only if the world can take it now, such as a cost the money on hand can pay.
+    const draft = { kind: 'world', actorId: null, placeId, summary: 'A due happening.', narration: null, outcome: null, minutes: 0, causeSeq: null, importance: 1, suggestions: [], reach: 'here', notice: null, effects: [] };
+    const kept = [];
+    for (const effect of results) {
+        try {
+            applyLivingEvent(state, { seq: state.revision + 1, at: state.clock, witnessIds: witnessesFor(state, draft), nearbyIds: nearbyFor(state, draft), ...draft, effects: [...kept, effect] });
+            kept.push(effect);
+        }
+        catch (error) {
+            if (!(error instanceof LivingWorldError))
+                throw error;
+        }
+    }
+    return kept;
+}
+function describeResult(state, effect) {
+    const holder = (id) => id === null ? 'outside the world' : state.accounts?.[id]?.name ?? personLabel(state, id);
+    switch (effect.kind) {
+        case 'fact': return effect.add ?? '';
+        case 'tension.update': return `${state.tensions.find(tension => tension.id === effect.tensionId)?.title ?? effect.tensionId}: ${effect.note ?? effect.status}`;
+        case 'transfer': return `${effect.amount}${state.currency ? ` ${state.currency.name}` : ''} pass from ${holder(effect.fromId)} to ${holder(effect.toId)}`;
+        default: return '';
+    }
+}
+// Every two game hours the world takes up the open problem nobody has acted on longest and rules how
+// it goes on by itself: the rigs unload, the patient worsens, the deadline passes.
+async function stallCheck(session, due) {
+    const state = session.state;
+    const again = nextTime(due);
+    const stalled = state.tensions.filter(tension => tension.status === 'open' && state.clock - tension.changedAt >= STALL_MINUTES)
+        .sort((left, right) => left.changedAt - right.changedAt || left.id.localeCompare(right.id))[0];
+    if (stalled === undefined) {
+        // The engine's own check is no event in the world: no one sees it.
+        session.commit({ kind: 'world', actorId: null, placeId: session.player().placeId, summary: 'No open problem has stood still', narration: null, outcome: null, minutes: 0,
+            effects: [{ kind: 'unschedule', scheduledId: due.id }, ...again(state)], causeSeq: null, importance: 1, suggestions: [], ...quiet, perceivedBy: [] });
+        return true;
+    }
+    // It goes on where those it concerns are.
+    const placeId = stalled.participantIds.map(id => state.people[id]).find(person => person !== undefined && !person.isPlayer && !person.away && !person.departed)?.placeId
+        ?? session.player().placeId;
+    try {
+        await resolve(session, {
+            phase: 'world', actorId: null, placeId, kind: 'world', causeSeq: null, extraEffects: [{ kind: 'unschedule', scheduledId: due.id }], clears: again,
+            input: (errors, fitted, focusIds) => gameMasterWorldInput(session.state, { intent: `${stalled.title}: ${stalled.summary}`.slice(0, 600), placeId, sourceSeq: 0, targetId: stalled.id, id: due.id }, errors, fitted, focusIds),
+            summary: ruling => ruling.record,
+            trigger: ruling => ({ kind: 'world', actorId: null, text: ruling.observed ?? ruling.narration, narration: ruling.narration }),
+            // What the ruling made of it becomes where the problem now stands.
+            rulingEffects: (_state, ruling) => ruling.settledTensionId === stalled.id ? [] : [{ kind: 'tension.update', tensionId: stalled.id, status: 'open', note: ruling.record.slice(0, 2000) }],
+            movesNoMoney: true,
+            // Where the problem stood, said again word for word, is no development.
+            nothingNew: ruling => ruling.settledTensionId === null && ruling.newTension === null && ruling.effects.length === 0 && ruling.record.trim() === stalled.summary.trim(),
+        });
+        return true;
+    }
+    catch (error) {
+        if (!(error instanceof LivingWorldError))
+            throw error;
+        if (error.code === 'inference-unavailable' || error.code === 'inference-invalid')
+            return false;
+        throw error;
+    }
+}
+// A world happening that fell due is carried out by the Game Master: the ambulances
+// arrive, the fire spreads or dies, the storm hits, security walks in.
+async function worldFollowUp(session, due) {
+    if (due.series === 'stall-check')
+        return stallCheck(session, due);
+    const state = session.state;
+    const placeId = due.placeId && state.places[due.placeId] ? due.placeId : session.player().placeId;
+    const beat = due.beat;
+    // A deadline whose problem was settled first does not happen; no one needs to rule it.
+    const settledFirst = beat?.unless ? state.tensions.find(tension => tension.id === beat.unless.settled && tension.status === 'settled') : undefined;
+    if (settledFirst) {
+        session.commit({ kind: 'world', actorId: null, placeId, summary: `Averted: ${due.intent} (${settledFirst.title} was settled first)`.slice(0, 2000), narration: null, outcome: null, minutes: 0,
+            effects: [{ kind: 'unschedule', scheduledId: due.id }, ...nextTime(due)(state),
+                ...(beat.deadline ? [{ kind: 'deadline.passed', what: due.intent.slice(0, MAX_LINE), outcome: `Averted: ${settledFirst.title} was settled first.`.slice(0, MAX_LINE),
+                        ...(state.engine >= AVERTED_ENGINE ? { averted: true } : {}) }] : [])],
+            causeSeq: null, importance: 2, suggestions: [], ...quiet });
+        return true;
+    }
+    // What the world's data says this happening changes applies whatever the Game Master rules.
+    const typed = (world) => beatResults(world, placeId, beat);
+    try {
+        const again = nextTime(due);
+        await resolve(session, {
+            phase: 'world', actorId: null, placeId, kind: 'world', causeSeq: due.sourceSeq || null, extraEffects: [{ kind: 'unschedule', scheduledId: due.id }], clears: again, concerns: due.targetId,
+            input: (errors, fitted, focusIds) => gameMasterWorldInput(session.state, { intent: due.intent, placeId, sourceSeq: due.sourceSeq, targetId: due.targetId, id: due.id,
+                ...(due.everyMinutes === undefined ? {} : { everyMinutes: due.everyMinutes }), alreadyTrue: typed(session.state).map(effect => describeResult(session.state, effect)) }, errors, fitted, focusIds),
+            rulingEffects: (world, ruling) => [...typed(world),
+                ...(beat?.deadline ? [{ kind: 'deadline.passed', what: due.intent.slice(0, MAX_LINE), outcome: (ruling.observed ?? ruling.record).slice(0, MAX_LINE) }] : [])],
+            ...(beat?.reach ? { reach: { reach: beat.reach, notice: beat.heard ?? null } } : {}),
+            summary: ruling => ruling.record,
+            // What the world's data says happens is seen by everyone there.
+            seenByAll: (due.series ?? due.id).startsWith('beat-'),
+            // A happening that comes back is told anew each time.
+            repeats: ruling => {
+                const before = due.everyMinutes === undefined ? undefined : earlierTimes(session.state, due.sourceSeq).find(time => time.what === ruling.observed);
+                return before ? `This is word for word what happened at ${before.at}; tell what happens this time.` : null;
+            },
+            // People there perceive the happening, never the intent or record that caused it.
+            trigger: ruling => ({ kind: 'world', actorId: null, text: ruling.observed ?? ruling.narration, narration: ruling.narration }),
+        });
+        return true;
+    }
+    catch (error) {
+        if (!(error instanceof LivingWorldError))
+            throw error;
+        if (error.code !== 'inference-unavailable' && error.code !== 'inference-invalid')
+            throw error;
+        // A deadline comes whether or not anyone can tell it well: a little after its time it happens
+        // with what its data says it changes, in its own words and as far as it carries.
+        if (beat?.deadline && session.state.clock - due.at >= DEADLINE_GRACE_MINUTES) {
+            const world = session.state;
+            session.commit({ kind: 'world', actorId: null, placeId, summary: due.intent, narration: null, outcome: null, minutes: 0,
+                effects: [{ kind: 'unschedule', scheduledId: due.id }, ...nextTime(due)(world), ...typed(world),
+                    { kind: 'deadline.passed', what: due.intent.slice(0, MAX_LINE), outcome: (beat.heard ?? due.intent).slice(0, MAX_LINE) }],
+                causeSeq: due.sourceSeq || null, importance: due.importance, suggestions: [], ...quiet, observed: beat.heard ?? due.intent,
+                ...(beat.reach ? { reach: beat.reach, notice: beat.heard ?? null } : {}) });
+            return true;
+        }
+        // Keep the due item for a later try. A failed answer says nothing about whether the event happened.
+        return false;
+    }
+}
+// With nothing scheduled, idle characters think about what to do next.
+async function idleTick(session) {
+    const state = session.state;
+    const lastDecision = (personId) => [...state.events].reverse().find(event => event.actorId === personId && event.kind === 'plan')?.seq ?? 0;
+    // A promise kept later is no plan for now; the person still decides what to do meanwhile.
+    const idle = Object.values(state.people).filter(person => !person.isPlayer && !person.incapacitated && person.plan === null
+        && !hasPlanned(state, person.id))
+        .sort((left, right) => lastDecision(left.id) - lastDecision(right.id) || left.id.localeCompare(right.id));
+    for (const person of idle.slice(0, MAX_DUE_ITEMS_PER_STEP)) {
+        if (!session.canSpend())
+            break;
+        await carryOutPlan(session, { id: generatedId(session.state.engine, 'idle', [session.state.revision + 1, person.id]), at: session.state.clock, personId: person.id, kind: 'plan', intent: 'idle', placeId: null, targetId: null, sourceSeq: session.state.revision, importance: 1 }, false);
+    }
+}
+function parsePlan(answer) {
+    const value = answer;
+    const actions = ['go', 'speak', 'message', 'attempt', 'go-home', 'wait'];
+    if (!value || typeof value !== 'object' || typeof value.action !== 'string' || !actions.includes(value.action) || typeof value.mood !== 'string')
+        throw new LivingWorldError('inference-invalid', 'The plan answer is malformed');
+    const text = typeof value.text === 'string' && value.text.trim() !== '' ? value.text.trim().slice(0, MAX_SPOKEN) : null;
+    const request = value.request && typeof value.request === 'object' ? value.request : null;
+    return {
+        action: value.action,
+        placeId: typeof value.placeId === 'string' ? value.placeId : null,
+        targetId: typeof value.targetId === 'string' ? value.targetId : null,
+        text,
+        mood: cleanMood(value.mood, 'Present'),
+        nextPlan: parsePlanValue(value.nextPlan, 60),
+        request: request && typeof request.topic === 'string' && request.topic.trim() !== ''
+            ? { topic: request.topic.trim().slice(0, 600), priorId: typeof request.priorId === 'string' ? request.priorId : null } : null,
+        stance: ['undecided', 'cooperate', 'refuse', 'report', 'avoid', 'confront'].includes(value.stance) ? value.stance : null,
+        ballot: parseBallot(value.ballot),
+    };
+}
+async function carryOutPlan(session, due, scheduled) {
+    const release = await session.takeTurn(due.personId);
+    try {
+        return await decidePlan(session, due, scheduled, release);
+    }
+    finally {
+        release();
+    }
+}
+// The person's turn ends once their decision is recorded, before the world answers what they do.
+async function decidePlan(session, due, scheduled, release) {
+    let asked = session.state;
+    const personId = due.personId;
+    // An idle person has no due plan; they decide from their own goals and state.
+    // How late the plan is depends on the moment the person decides; a decision made again sees it anew.
+    // A due item that names where and with whom, such as a promise to keep, says so.
+    const where = due.placeId !== null || due.targetId !== null ? { placeId: due.placeId, targetId: due.targetId } : {};
+    const dueAt = (world) => !scheduled ? null : world.clock - due.at >= 30 ? { intent: due.intent, ...where, overdueMinutes: world.clock - due.at } : { intent: due.intent, ...where };
+    let dueIntent = dueAt(asked);
+    // A member's turn to vote, given when voting opens.
+    const voteTurn = scheduled && due.id.startsWith('vote-');
+    // The decision is made on the world as it is when the call goes.
+    const build = (focusIds = []) => {
+        asked = session.state;
+        dueIntent = dueAt(asked);
+        const input = characterPlanInput(asked, asked.people[personId], dueIntent, voteTurn, focusIds);
+        return { input, responseSchema: scopedPlanResponseSchema(input) };
+    };
+    // The world goes on while the person decides. A decision for an activity that another event has
+    // already replaced, or by someone who can no longer act, is set aside, and a call still waiting its
+    // turn for it is not sent; the newer course stands.
+    const stillDue = (world) => {
+        const who = world.people[personId];
+        return who !== undefined && !who.incapacitated && who.departed === undefined && who.away === undefined
+            && (scheduled ? world.schedule.some(item => item.id === due.id && item.sourceSeq === due.sourceSeq) : !hasPlanned(world, personId));
+    };
+    let answer;
+    try {
+        answer = parsePlan(await session.complete({ role: 'character', phase: 'plan', system: CHARACTER_PLAN_SYSTEM, ...build(), ...LIVING_INFERENCE_LIMITS.plan }, personId, null, build, () => stillDue(session.state)));
+    }
+    catch (error) {
+        // The plan stays pending when the model is unavailable; a malformed answer is a real failure.
+        if (error instanceof LivingWorldError && error.code === 'inference-unavailable')
+            return false;
+        if (error instanceof LivingWorldError && error.code === 'run-paused' && !session.state.paused && !stillDue(session.state))
+            return true;
+        throw error;
+    }
+    if (!stillDue(session.state))
+        return true;
+    // A decision that began before this person spoke or acted again, or before someone spoke to
+    // them, answers a moment that has passed; they decide once more on what is now true.
+    const movedOn = (since) => session.state.events.some(event => event.seq > since && (event.actorId === personId
+        || event.effects.some(effect => (effect.kind === 'say' || effect.kind === 'message') && effect.toIds.includes(personId))));
+    if (answer.action !== 'wait' && movedOn(asked.revision)) {
+        const now = session.state;
+        let decidedAt = asked.revision;
+        if (session.canSpend()) {
+            decidedAt = now.revision;
+            try {
+                answer = parsePlan(await session.complete({
+                    role: 'character', phase: 'plan', system: CHARACTER_PLAN_SYSTEM, ...build(), ...LIVING_INFERENCE_LIMITS.plan,
+                }, personId, null, build, () => stillDue(session.state)));
+            }
+            catch (error) {
+                if (!(error instanceof LivingWorldError) || (error.code !== 'inference-invalid' && error.code !== 'inference-unavailable'))
+                    throw error;
+                answer = { ...answer, action: 'wait', text: null };
+            }
+            if (!stillDue(session.state))
+                return true;
+        }
+        if (answer.action !== 'wait' && movedOn(decidedAt))
+            answer = { ...answer, action: 'wait', text: null };
+    }
+    if (!stillDue(session.state))
+        return true;
+    let state = session.state;
+    // Words that ask again what was already asked, or that go to someone who has left this person's last
+    // lines unanswered, are left unsaid; the rest of the decision, with its next activity, stands.
+    const prior = answer.request?.priorId ? state.requests.find(request => request.id === answer.request.priorId) : null;
+    const reminding = (answer.action === 'speak' || answer.action === 'message') && reminderDue(state, prior, personId, answer.targetId);
+    const unsaid = (answer.action === 'speak' || answer.action === 'message') && answer.targetId !== null
+        && (prior?.receiverId === answer.targetId && !reminding || unansweredSince(state, personId, answer.targetId) !== null
+            || answer.text !== null && saidAlready(state, personId, answer.text));
+    if (unsaid)
+        answer = { ...answer, action: 'wait', text: null };
+    // A vote cast in this decision is its own act, seen by those present, before whatever else the person does.
+    const voted = voteTurn ? ballotEffects(session.state, personId, answer.ballot, 'any') : [];
+    if (voted[0]?.kind === 'ballot') {
+        const voter = session.state.people[personId];
+        session.commit({ kind: 'reaction', actorId: personId, placeId: voter.placeId, summary: `${voter.name} votes ${voted[0].choice} on ${session.state.entities[voted[0].entityId].name}`.slice(0, 2000),
+            narration: null, outcome: null, minutes: 0, effects: voted, causeSeq: due.sourceSeq || null, importance: 3, suggestions: [], ...quiet });
+    }
+    state = session.state;
+    const person = state.people[personId];
+    const seq = state.revision + 1;
+    const live = session.live();
+    // A plan that waits twice for itself ends here. In a live world a plan is an activity, and
+    // a decision that names none keeps the person at what they were doing a while longer.
+    const again = !live && (state.engine >= BOUNDED_IDENTIFIERS_ENGINE ? due.replanned === true : due.id.endsWith('-again'));
+    const stale = !live && answer.nextPlan !== null && answer.action === 'wait';
+    if (stale && again)
+        answer.nextPlan = null;
+    // Someone another person there holds, by hand or by a typed gate, cannot walk away; a gate on speech,
+    // messages or acts turns that plan into waiting.
+    const kept = heldHere(state, person.id) || blockedByGate(state, person.id, 'move') !== null;
+    if (kept && (answer.action === 'go' || answer.action === 'go-home')) {
+        answer.action = 'wait';
+        answer.text = null;
+    }
+    // Someone back from home stays at least two hours before going home again; they carry on with the day.
+    if (answer.action === 'go-home' && person.restedAt !== undefined && state.clock - person.restedAt < DAY_AWAY_MINUTES) {
+        answer = { ...answer, action: 'wait', text: null, nextPlan: null };
+    }
+    const gatedPlan = answer.action === 'speak' ? 'speak' : answer.action === 'message' ? 'message' : answer.action === 'attempt' ? 'act' : null;
+    if (gatedPlan !== null && blockedByGate(state, person.id, gatedPlan) !== null) {
+        answer.action = 'wait';
+        answer.text = null;
+    }
+    const valid = answer.nextPlan && (answer.nextPlan.placeId === null || state.places[answer.nextPlan.placeId]) && (answer.nextPlan.targetId === null || state.people[answer.nextPlan.targetId]) ? answer.nextPlan : null;
+    // Someone whose words were held back waits for an answer, not for their next try at saying them.
+    const named = valid && unsaid ? { ...valid, targetId: null, inMinutes: Math.max(valid.inMinutes, DEFAULT_ACTIVITY_MINUTES) } : valid;
+    const next = named ?? (live ? { intent: person.plan?.intent ?? 'Carry on with the day', ...(person.plan?.seen ? { seen: person.plan.seen } : {}),
+        placeId: null, targetId: null, inMinutes: DEFAULT_ACTIVITY_MINUTES } : null);
+    const remaining = { ...state, schedule: state.schedule.filter(item => item.id !== due.id) };
+    const mood = answer.mood;
+    // A due decision about someone's serious act records where this person now stands.
+    const standing = isDecision(due) && answer.stance !== null
+        ? state.stances.find(stance => stance.personId === person.id && stance.actorId === due.targetId) : undefined;
+    const base = [
+        ...(scheduled ? [{ kind: 'unschedule', scheduledId: due.id }] : []),
+        ...(mood !== person.mood ? [{ kind: 'mood', personId: person.id, mood }] : []),
+        ...(standing && answer.stance !== null ? [{ kind: 'stance', personId: person.id, actorId: standing.actorId, status: answer.stance, sourceSeq: standing.sourceSeq }] : []),
+    ];
+    const newRequest = answer.request && answer.request.priorId === null && answer.targetId && answer.text
+        && (answer.action === 'speak' || answer.action === 'message')
+        ? [{ kind: 'request.open', requestId: generatedId(session.state.engine, 'request', [seq, person.id]), senderId: person.id,
+                receiverId: answer.targetId, topic: answer.request.topic }]
+        : reminding && !unsaid && prior ? [{ kind: 'request.remind', requestId: prior.id }] : [];
+    const follow = next ? planEffects(remaining, person.id, next, seq, stale ? '-again' : '') : [{ kind: 'plan', personId: person.id, plan: null }];
+    const cause = due.sourceSeq || null;
+    const target = answer.targetId && state.people[answer.targetId] ? state.people[answer.targetId] : null;
+    // A next activity somewhere else begins with the walk there, so nobody stands for hours getting ready to leave.
+    if (!kept && answer.action === 'wait' && named?.placeId && named.placeId !== person.placeId && state.places[named.placeId]) {
+        answer = { ...answer, action: 'go', placeId: named.placeId };
+    }
+    const wantsToTravel = !kept && (answer.action === 'go' ? answer.placeId !== null && state.places[answer.placeId] !== undefined && answer.placeId !== person.placeId
+        : answer.action === 'speak' && target !== null && target.placeId !== person.placeId);
+    if (answer.action === 'attempt' && answer.text) {
+        // A character's attempt goes through the same adjudication as the player's.
+        session.commit({ kind: 'plan', actorId: person.id, placeId: person.placeId, summary: `${person.name} decides: ${answer.text}`.slice(0, 2000), narration: null, outcome: null, minutes: 0, effects: [...base, ...follow], causeSeq: cause, importance: 2, suggestions: [], ...quiet });
+        release();
+        try {
+            await adjudicate(session, person.id, answer.text);
+        }
+        catch (error) {
+            if (!(error instanceof LivingWorldError) || (error.code !== 'inference-invalid' && error.code !== 'inference-unavailable'))
+                throw error;
+        }
+        return true;
+    }
+    // Going home takes the person off the map, to rest, sleep or an errand, until their next activity ends.
+    if (answer.action === 'go-home') {
+        const reason = (answer.text ?? named?.intent ?? 'Away for a while').slice(0, MAX_LINE);
+        // A visitor brought in mid-story who goes home has left it; anyone else is home at least the night.
+        if (person.newcomer) {
+            session.commit({ kind: 'move', actorId: person.id, placeId: person.placeId, summary: `${person.name} leaves: ${reason}`.slice(0, 2000), narration: null, outcome: null, minutes: 0,
+                effects: [...base, { kind: 'person.leave', personId: person.id, reason }], causeSeq: cause, importance: 2, suggestions: [], ...quiet, observed: `${person.name} leaves.` });
+            return true;
+        }
+        // Home until the night is over, or until in time for a promise that falls due sooner.
+        const promised = person.commitments.filter(commitment => commitment.status === 'open' && commitment.dueAt !== null && commitment.dueAt > state.clock)
+            .map(commitment => commitment.dueAt - state.clock - PROMISE_LEAD_MINUTES);
+        const night = isNight(state.clock) || state.clock - (person.restedAt ?? state.startClock ?? 0) >= LONG_DAY_MINUTES;
+        const least = night ? GO_HOME_MINUTES : DAY_AWAY_MINUTES;
+        const minutes = Math.max(AWAY_MINUTES.min, Math.min(Math.max(least, Math.min(AWAY_MINUTES.max, named?.inMinutes ?? least)), ...promised));
+        session.commit({ kind: 'move', actorId: person.id, placeId: person.placeId, summary: `${person.name} goes home: ${reason}`.slice(0, 2000), narration: null, outcome: null, minutes: 0,
+            effects: [...base, { kind: 'person.away', personId: person.id, minutes, reason }], causeSeq: cause, importance: 2, suggestions: [], ...quiet, observed: `${person.name} leaves.` });
+        return true;
+    }
+    if (wantsToTravel) {
+        const destination = answer.action === 'go' ? answer.placeId : target.placeId;
+        const path = travelPath(state, person.placeId, destination);
+        if (!path) {
+            session.commit({ kind: 'plan', actorId: person.id, placeId: person.placeId, summary: `${person.name} cannot reach ${state.places[destination].name}`, narration: null, outcome: null, minutes: 0, effects: [...base, ...follow], causeSeq: cause, importance: 1, suggestions: [], ...quiet });
+            return true;
+        }
+        // Words for someone elsewhere are chosen on arrival, from what is there then.
+        const arrival = answer.action === 'speak' && answer.text
+            ? planEffects(remaining, person.id, { intent: `Say to ${target.name} what you came to say: ${answer.text}`.slice(0, 300), seen: `on the way to ${target.name}`,
+                placeId: destination, targetId: target.id, inMinutes: (path.length - 1) * TRAVEL_MINUTES_PER_HOP }, seq)
+            : follow;
+        session.commit({
+            kind: 'move', actorId: person.id, placeId: person.placeId, summary: `${person.name} travels to ${state.places[destination].name}`, narration: null, outcome: null, minutes: (path.length - 1) * TRAVEL_MINUTES_PER_HOP,
+            observed: `${person.name} leaves toward ${firstRoom(state, path)}.`,
+            effects: [...base, { kind: 'move', personId: person.id, placeId: destination }, ...arrival], causeSeq: cause, importance: 2, suggestions: [], ...quiet,
+        });
+        return true;
+    }
+    if (answer.action === 'speak' && answer.text && target && isHere(state, target.id, person.placeId)) {
+        const event = session.commit({
+            kind: 'reaction', actorId: person.id, placeId: person.placeId, summary: `${person.name} says to ${target.name}: "${answer.text}"`.slice(0, 2000), narration: null, outcome: null, minutes: SPEECH_MINUTES,
+            effects: [...base, { kind: 'say', personId: person.id, text: answer.text, toIds: [target.id] }, ...newRequest, ...follow], causeSeq: cause, importance: 3, suggestions: [], ...quiet,
+        });
+        release();
+        await replyBetween(session, person.id, target.id, event, answer.text);
+        return true;
+    }
+    if (answer.action === 'message' && answer.text && target) {
+        const travel = state.messageTravel;
+        const opened = newRequest[0]?.kind === 'request.open' ? { requestId: newRequest[0].requestId, topic: newRequest[0].topic } : undefined;
+        session.commit({
+            kind: 'message', actorId: person.id, placeId: person.placeId, summary: `${person.name} sends a message to ${target.name}${travel ? ` ${travel.how}` : ''}`, narration: null, outcome: null, minutes: MESSAGE_MINUTES,
+            effects: travel ? [...base, dispatch(seq, 0, { fromId: person.id, toIds: [target.id], text: answer.text, replies: true, request: opened }),
+                ...newRequest.filter(effect => effect.kind === 'request.remind'), ...follow] : [
+                ...base, { kind: 'message', fromId: person.id, toIds: [target.id], text: answer.text }, ...newRequest,
+                ...(target.isPlayer ? [] : [{ kind: 'schedule', scheduledId: generatedId(session.state.engine, 'reply', [seq, target.id]), personId: target.id, inMinutes: MESSAGE_REPLY_DELAY_MINUTES, intent: answer.text, placeId: null, targetId: person.id, scheduleKind: 'reply' }]),
+                ...follow,
+            ],
+            causeSeq: cause, importance: 3, suggestions: [], ...quiet,
+        });
+        return true;
+    }
+    session.commit({
+        kind: 'plan', actorId: person.id, placeId: person.placeId, summary: next ? `${person.name} makes a plan: ${next.intent}`.slice(0, 2000) : dueIntent?.overdueMinutes === undefined ? `${person.name} waits` : `${person.name} drops the overdue plan and waits`, narration: null, outcome: null, minutes: 0,
+        effects: [...base, ...follow], causeSeq: cause, importance: 1, suggestions: [], ...quiet,
+        // What onlookers see, as a label beside the name, not a sentence the free text must finish.
+        ...(next?.seen ? { observed: `${person.name}: ${next.seen}`.slice(0, 600) } : {}),
+        ...(unsaid ? { droppedEffects: 1 } : {}),
+    });
+    return true;
+}
+async function answerMessage(session, due) {
+    const release = await session.takeTurn(due.personId);
+    try {
+        return await replyToMessage(session, due);
+    }
+    finally {
+        release();
+    }
+}
+async function replyToMessage(session, due) {
+    let state = session.state;
+    const person = state.people[due.personId];
+    const fromId = due.targetId ?? state.playerId;
+    const answeredInPerson = state.events.some(event => event.causeSeq === due.sourceSeq
+        && event.effects.some(effect => effect.kind === 'say' && effect.personId === person.id && effect.toIds.includes(fromId)));
+    if (answeredInPerson) {
+        session.commit({
+            kind: 'message', actorId: person.id, placeId: person.placeId, summary: `${person.name} sets ${personLabel(state, fromId)}'s message aside; it was answered in person`,
+            narration: null, outcome: null, minutes: 0, effects: [{ kind: 'unschedule', scheduledId: due.id }], causeSeq: due.sourceSeq || null, importance: 1, suggestions: [], ...quiet,
+        });
+        return true;
+    }
+    let value;
+    const build = (focusIds = []) => ({ input: characterMessageReplyInput(session.state, session.state.people[person.id], { fromId, text: due.intent }, focusIds), responseSchema: messageReplyResponseSchema });
+    try {
+        value = await session.complete({ role: 'character', phase: 'message-reply', system: CHARACTER_MESSAGE_SYSTEM, ...build(), ...LIVING_INFERENCE_LIMITS['message-reply'] }, person.id, due.sourceSeq, build);
+    }
+    catch (error) {
+        if (error instanceof LivingWorldError && error.code === 'inference-unavailable')
+            return false;
+        throw error;
+    }
+    if (!value || typeof value !== 'object' || typeof value.mood !== 'string')
+        throw new LivingWorldError('inference-invalid', 'The message answer is malformed');
+    // The world went on while they wrote: someone struck down or gone meanwhile sends nothing, and a
+    // reply already handled is not handled twice.
+    const writer = session.state.people[person.id];
+    if (!writer || writer.incapacitated || writer.departed || !session.state.schedule.some(item => item.id === due.id))
+        return true;
+    state = session.state;
+    const raw = typeof value.reply === 'string' && value.reply.trim() !== '' ? value.reply.trim().slice(0, MAX_SPOKEN) : null;
+    const reply = raw;
+    const belief = value.belief && typeof value.belief === 'object' ? value.belief : null;
+    const plan = parsePlanValue(value.plan, 30);
+    const trust = clampInt(value.trust, -20, 20, 0);
+    const warmth = clampInt(value.warmth, -20, 20, 0);
+    const seq = state.revision + 1;
+    const mood = cleanMood(value.mood, writer.mood);
+    const effects = [
+        { kind: 'unschedule', scheduledId: due.id },
+        ...(mood !== writer.mood ? [{ kind: 'mood', personId: person.id, mood }] : []),
+        ...(reply && blockedByGate(state, person.id, 'message') === null ? [state.messageTravel ? dispatch(seq, 0, { fromId: person.id, toIds: [fromId], text: reply, replies: false })
+                : { kind: 'message', fromId: person.id, toIds: [fromId], text: reply }] : []),
+        ...((trust !== 0 || warmth !== 0) && fromId !== person.id && state.people[fromId] ? [{ kind: 'relationship', personId: person.id, targetId: fromId, trust, warmth, note: '' }] : []),
+        ...(belief && typeof belief.subject === 'string' && typeof belief.claim === 'string' && belief.subject.trim() !== '' && belief.claim.trim() !== '' ? [{ kind: 'belief', personId: person.id, subject: belief.subject.trim().slice(0, 120), claim: belief.claim.trim().slice(0, 300), sourcePersonId: state.people[fromId] ? fromId : null,
+                evidence: { kind: 'told', eventSeq: due.sourceSeq, sourceId: fromId } }] : []),
+        // Someone answering from home decides what to do next once back.
+        ...(plan && !writer.away && (plan.placeId === null || state.places[plan.placeId]) && (plan.targetId === null || state.people[plan.targetId]) ? planEffects({ ...state, schedule: state.schedule.filter(item => item.id !== due.id) }, person.id, plan, seq) : []),
+    ];
+    session.commit({
+        kind: 'message', actorId: person.id, placeId: person.placeId,
+        summary: reply ? `${person.name} replies to ${personLabel(state, fromId)}'s message` : `${person.name} reads ${personLabel(state, fromId)}'s message and does not reply`,
+        narration: null, outcome: null, minutes: 0, effects, causeSeq: due.sourceSeq || null, importance: 3, suggestions: [], ...quiet,
+        // No one where they left sees someone at home write.
+        ...(writer.away ? { perceivedBy: [] } : {}),
+    });
+    return true;
+}