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

package/dist/simulation/living/context.js

@@ -0,0 +1,944 @@
+import { compactModelInput, decisionInputBudget, MODEL_VIEW_NOTE, selectModelPeople, syncModelPeople } from './model-input.js';
+import { recallBeliefs, recallMemories } from './recall.js';
+import { attemptResponseSchema, epilogueResponseSchema, messageReplyResponseSchema, planResponseSchema, reactionResponseSchema, responseFieldLines, speechImpactResponseSchema } from './inference.js';
+import { blockedActionKinds, currentValue, placelessNear } from './mechanics.js';
+import { peopleAt, unansweredSince, votingShut } from './reduce.js';
+import { knowsCustody, observedSummary, visibleTo, witnessed } from './projection.js';
+import { SHARED_KINDS, sealedPaper, staysInPlace } from './shared-kinds.js';
+import { CHRONICLE_ENGINE, IDENTITY_ENGINE, LONG_DAY_MINUTES, PLAYER_QUIET_MINUTES, PLAYER_REST_ENGINE, SEEN_AT_EVENTS_ENGINE, WHOLE_TEXT_ENGINE, WRITING_GROWS_ENGINE, clockLabel, isNight } from './types.js';
+// Context builders turn state into what one participant can know right now.
+// The Game Master sees the world. A character sees their own mind and their scene.
+// A serious thing stays pressing for this long: people do not go back to routine
+// business within minutes of violence, fire, theft or a collapse.
+export const PRESSING_MINUTES = 240;
+export const PRESSING_IMPORTANCE = 6;
+// Memories this grave stay in a person's mind for good, the gravest few of them.
+const LANDMARK_IMPORTANCE = 8;
+const LANDMARKS = 4;
+// Each model call sees a bounded, relevant slice of a person's growing lists.
+export const MIND_SLICE = 8;
+// The newest things at a place that a scene lists, before the input budget trims it.
+export const SCENE_SLICE = 32;
+const REQUEST_SLICE = 12;
+// Refused and open requests stay in view before settled ones, newest first within each.
+function relevantRequests(requests) {
+    const rank = (request) => request.status === 'refused' || request.status === 'open' ? 0 : 1;
+    return [...requests].sort((left, right) => rank(left) - rank(right) || right.openedSeq - left.openedSeq)
+        .slice(0, REQUEST_SLICE).sort((left, right) => left.openedSeq - right.openedSeq);
+}
+export { clockLabel };
+export function personLabel(state, personId) {
+    return state.people[personId]?.name ?? personId;
+}
+function placeLabel(state, placeId) {
+    return placeId === null ? null : state.places[placeId]?.name ?? placeId;
+}
+function personCard(state, id) {
+    const person = state.people[id];
+    // What anyone present can see the person doing; their purpose stays private. Someone whose next activity
+    // is somewhere else is seen getting ready to leave, not doing what they mean to do there.
+    const plan = person.plan;
+    const elsewhere = state.engine >= IDENTITY_ENGINE && plan?.placeId !== undefined && plan.placeId !== null && plan.placeId !== person.placeId;
+    // The player's person, two quiet game hours after the player last acted, is seen resting, or asleep at
+    // night; never while a long act of theirs is under way.
+    const resting = state.engine >= PLAYER_REST_ENGINE && person.isPlayer && state.clock - (state.playerActedAt ?? state.startClock ?? 0) >= PLAYER_QUIET_MINUTES
+        && !state.schedule.some(item => item.kind === 'finish' && item.targetId === person.id)
+        ? isNight(state.clock) ? 'asleep where they sit' : 'resting quietly, not taking part' : null;
+    return { id, name: person.name, role: person.role, pronouns: person.pronouns ?? 'they/them', summary: person.summary,
+        ...(person.arrivedAt === undefined ? {} : { arrived: clockLabel(person.arrivedAt) }),
+        mood: null, condition: person.condition ?? null, doing: person.incapacitated ? null : resting ?? (elsewhere ? 'getting ready to leave' : plan?.seen ?? null),
+        held: null, incapacitated: person.incapacitated };
+}
+export function describeScene(state, placeId, viewerId, kept = new Set()) {
+    const place = state.places[placeId];
+    const people = peopleAt(state, placeId).filter(id => id !== viewerId).map((id) => {
+        const holding = [...Object.values(state.objects).filter(object => object.holderId === id
+                && (viewerId === null || knowsCustody(state, object, viewerId))).map(object => object.name),
+            ...(state.entityPlaceIds[placeId] ?? []).filter(entityId => state.entities[entityId].holderId === id
+                && (viewerId === null || state.entities[entityId].knownTo.includes(viewerId))).map(entityId => state.entities[entityId].name)];
+        return { ...personCard(state, id), holding };
+    });
+    // A thing the world hides is seen only by those who know where it is.
+    const objects = Object.values(state.objects).filter(object => object.placeId === placeId
+        && (!object.hidden || viewerId === null || object.holderId === viewerId || object.custodyKnownTo.includes(viewerId))).map(object => ({
+        id: object.id, name: object.name, summary: viewerId !== null && object.holderId !== viewerId && !object.conditionKnownTo.includes(viewerId) ? 'An object here.' : object.summary,
+        condition: viewerId !== null && object.holderId !== viewerId && !object.conditionKnownTo.includes(viewerId) ? 'unexamined' : object.condition,
+        singlePersonMovable: object.singlePersonMovable,
+        ownerName: viewerId !== null && object.ownerId !== viewerId ? null : object.ownerId ? personLabel(state, object.ownerId) : null,
+        ...(viewerId === null && state.thingNotes[object.id] ? { refereeOnly: note(state.thingNotes[object.id]) } : {}),
+    }));
+    const near = new Set([placeId, ...peopleAt(state, placeId), ...(state.entityPlaceIds[placeId] ?? []).slice(-SCENE_SLICE),
+        ...Object.values(state.objects).filter(object => object.placeId === placeId).map(object => object.id), ...(viewerId === null ? [] : [viewerId])]);
+    // A scene lists the newest things at the place; the input budget trims further.
+    const here = state.entityPlaceIds[placeId] ?? [];
+    // What someone holds or just dealt with is listed however many newer things lie about.
+    const newest = [...here.filter(id => kept.has(id) && !here.slice(-SCENE_SLICE).includes(id)), ...here.slice(-SCENE_SLICE)];
+    // From engine 50 what lies in the open where the viewer stands is in view, and how it plainly is.
+    const standsHere = viewerId !== null && state.engine >= SEEN_AT_EVENTS_ENGINE && state.people[viewerId]?.placeId === placeId
+        && state.people[viewerId]?.away === undefined;
+    const inView = (entity) => standsHere && entity.placeId === placeId && entity.holderId === null && !entity.hidden;
+    const entities = [...placelessNear(state, near, MIND_SLICE), ...newest].map(id => state.entities[id])
+        .filter(entity => (viewerId === null || entity.knownTo.includes(viewerId) || inView(entity)) && !(entity.holderId && (state.people[entity.holderId]?.departed || state.people[entity.holderId]?.away)))
+        .map(entity => ({
+        id: entity.id, kindId: entity.kindId, kindName: state.kinds[entity.kindId].name, name: entity.name,
+        // A thing that is here can be picked up; who holds it is plain to see.
+        ...(entity.placeId === placeId ? { holderId: entity.holderId, ...(entity.condition ? { condition: entity.condition } : {}) } : {}),
+        // Who votes on a decision, as anyone who sees it knows.
+        ...(entity.members ? { members: entity.members } : {}),
+        // A sealed paper's words stay hidden from everyone in the world until it is opened.
+        properties: Object.fromEntries(Object.entries(entity.properties)
+            .filter(([key, slot]) => viewerId === null || (slot.knownTo.includes(viewerId) || inView(entity) && state.kinds[entity.kindId]?.properties.find(property => property.id === key)?.type !== 'text')
+            && !(sealedPaper(state.engine, entity) && state.kinds[entity.kindId]?.properties.find(property => property.id === key)?.type === 'text'))
+            .map(([key]) => [key, currentValue(state, entity, key, state.clock)])),
+        relations: Object.fromEntries(Object.entries(entity.relations)
+            .filter(([, slot]) => viewerId === null || slot.knownTo.includes(viewerId))
+            .map(([key, slot]) => [key, slot.targetId])),
+        // Only the Game Master reads what the last ruling did with it.
+        ...(viewerId === null && state.thingNotes[entity.id] ? { refereeOnly: note(state.thingNotes[entity.id]) } : {}),
+    }));
+    const exits = place.connections.map(id => ({ id, name: state.places[id]?.name ?? id }));
+    return { id: place.id, name: place.name, kind: place.kind, summary: place.summary, conditions: [...place.conditions], people, objects, entities, exits };
+}
+function recentSeqsAt(state, placeId, limit) {
+    return new Set(state.events.filter(event => event.placeId === placeId).slice(-limit).map(event => event.seq));
+}
+export function recentEventsAt(state, placeId, limit, viewerId, exceptSeq = null) {
+    return state.events
+        .filter(event => event.placeId === placeId && event.seq !== exceptSeq && (viewerId === null || witnessed(event, viewerId)))
+        .slice(-limit)
+        .map(event => ({ at: clockLabel(event.at), summary: viewerId === null ? event.summary : observedSummary(event, viewerId) }));
+}
+// The serious things that happened lately anywhere, so the world stays consistent
+// about them (security already called, a fire still burning, someone hurt).
+export function recentImportant(state, limit, shownHere = new Set()) {
+    // What was ruled to have happened, not what was said about it: talk stays with those who heard it.
+    return state.events
+        .filter(event => event.importance >= PRESSING_IMPORTANCE && (event.kind === 'attempt' || event.kind === 'world') && !shownHere.has(event.seq))
+        .slice(-limit)
+        .map(event => ({ at: clockLabel(event.at), place: placeLabel(state, event.placeId), summary: event.summary, witnesses: event.witnessIds.map(id => personLabel(state, id)) }));
+}
+export function openConversationAt(state, placeId, participantId) {
+    return state.conversations.find(conversation => conversation.endedAt === null && conversation.placeId === placeId && conversation.participantIds.includes(participantId)) ?? null;
+}
+// The event at which this person last walked into the place; lines said before that were not heard by them.
+export function joinedPlaceSeq(state, personId, placeId) {
+    const person = state.people[personId];
+    if (person?.placeId === placeId && person.arrivedSeq !== undefined)
+        return person.arrivedSeq;
+    for (let index = state.events.length - 1; index >= 0; index -= 1) {
+        const event = state.events[index];
+        if (event.effects.some(effect => effect.kind === 'move' && effect.personId === personId && effect.placeId === placeId))
+            return event.seq;
+    }
+    return 0;
+}
+// What this person said lately, anywhere: the lines they must not simply say again.
+export const RECENT_LINES_MINUTES = 180;
+export function recentLinesBy(state, personId, limit) {
+    return state.conversations
+        .flatMap(conversation => conversation.lines.filter(line => line.speakerId === personId && line.at >= state.clock - RECENT_LINES_MINUTES))
+        .sort((a, b) => a.seq - b.seq)
+        .slice(-limit);
+}
+function heardLines(state, placeId, participantId, limit) {
+    const conversation = openConversationAt(state, placeId, participantId);
+    if (!conversation)
+        return [];
+    const joined = joinedPlaceSeq(state, participantId, placeId);
+    return conversation.lines.filter(line => line.seq >= joined).slice(-limit);
+}
+function lineCard(state, line) {
+    return { speaker: personLabel(state, line.speakerId), speakerId: line.speakerId, to: line.toIds.map(id => personLabel(state, id)), text: line.text };
+}
+export function conversationLines(state, placeId, participantId, limit) {
+    return heardLines(state, placeId, participantId, limit).map(line => lineCard(state, line));
+}
+function note(entry) {
+    return { when: clockLabel(entry.at), what: entry.text };
+}
+export function worldDirectory(state, placeId) {
+    const localPlaces = new Set([placeId, ...state.places[placeId].connections]);
+    const localPeople = new Set(Object.values(state.people).filter(person => localPlaces.has(person.placeId) && person.away === undefined).map(person => person.id));
+    const away = Object.values(state.people).filter(person => localPlaces.has(person.placeId) && person.away !== undefined);
+    return {
+        places: Object.values(state.places).filter(place => localPlaces.has(place.id)).map(place => ({ id: place.id, name: place.name, kind: place.kind, connections: place.connections, conditions: [...place.conditions] })),
+        people: Object.values(state.people).filter(person => localPeople.has(person.id)).map(person => ({ id: person.id, name: person.name, role: person.role, pronouns: person.pronouns ?? 'they/them', placeId: person.placeId, isPlayer: person.isPlayer, incapacitated: person.incapacitated })),
+        // People from nearby who are off for a while, and where.
+        ...(away.length === 0 ? {} : { away: away.map(person => ({ id: person.id, name: person.name, where: person.away.reason })) }),
+        // Everyone else in the story, by name, so no one is brought in a second time.
+        elsewhere: Object.values(state.people).filter(person => !localPlaces.has(person.placeId) && person.departed === undefined).map(person => ({ id: person.id, name: person.name })),
+        // Things at this place are already in the scene; the directory lists the rest nearby and what people hold.
+        objects: Object.values(state.objects).filter(object => (object.placeId !== null && object.placeId !== placeId && localPlaces.has(object.placeId)) || (object.holderId !== null && localPeople.has(object.holderId)))
+            .map(object => ({ id: object.id, name: object.name, placeId: object.placeId, holderId: object.holderId, ownerId: object.ownerId, condition: object.condition, singlePersonMovable: object.singlePersonMovable })),
+        tensions: state.tensions.filter(tension => tension.status === 'open' && tension.participantIds.some(id => localPeople.has(id)))
+            .slice(-MIND_SLICE).map(tension => ({ id: tension.id, title: tension.title, summary: tension.summary, ...(tension.openedBy === undefined ? {} : { openedBy: tension.openedBy }),
+            participants: tension.participantIds.map(id => ({ id, name: personLabel(state, id) })) })),
+        facts: state.facts.slice(-8),
+        ...(state.startClock === undefined ? {} : { factsAsOf: clockLabel(state.startClock) }),
+    };
+}
+// A world begun on engines 42 to 44 adds each write to a paper as a line of its own, so its referee is told so.
+function writeRule(state) {
+    return state.engine >= WRITING_GROWS_ENGINE && state.engine < WHOLE_TEXT_ENGINE ? { textWrites: 'add' } : {};
+}
+function kindsInScope(state, placeId) {
+    const nearby = new Set([placeId, ...state.places[placeId].connections]);
+    const ids = new Set(SHARED_KINDS.map(kind => kind.id));
+    const near = new Set([...nearby, ...Object.values(state.people).filter(person => nearby.has(person.placeId)).map(person => person.id)]);
+    // Kinds of things here carry their rules; the rest are named and described, which is all a new thing needs.
+    const inView = new Set();
+    for (const entityId of placelessNear(state, near, MIND_SLICE)) {
+        ids.add(state.entities[entityId].kindId);
+        inView.add(state.entities[entityId].kindId);
+    }
+    for (const nearbyPlaceId of nearby)
+        for (const entityId of (state.entityPlaceIds[nearbyPlaceId] ?? []).slice(-SCENE_SLICE)) {
+            ids.add(state.entities[entityId].kindId);
+            if (nearbyPlaceId === placeId)
+                inView.add(state.entities[entityId].kindId);
+        }
+    for (const event of state.events.slice(-8)) {
+        for (const effect of event.effects)
+            if (effect.kind === 'kind.define') {
+                ids.add(effect.definition.id);
+                inView.add(effect.definition.id);
+            }
+    }
+    return [...ids].sort().map(id => state.kinds[id]).filter((kind) => kind !== undefined)
+        .map(kind => state.engine < IDENTITY_ENGINE || inView.has(kind.id) ? kind : { ...kind, mechanics: [], ...(staysInPlace(kind) ? { neverHeld: true } : {}) });
+}
+// The Game Master adjudicates against the whole world, so it sees the directory.
+export function gameMasterAttemptInput(state, actorId, attempt, previousErrors = [], _fitted = true, finishing, focusIds = []) {
+    const actor = state.people[actorId];
+    const close = inTalkWith(state, actor, focusIds);
+    const keeps = actorKeeps(state, actor.id, close);
+    const scene = describeScene(state, actor.placeId, null, keeps);
+    return fitInput({
+        phase: 'attempt',
+        clock: clockLabel(state.clock),
+        // The present as the count a time is written in: minutes since Day 1, 00:00.
+        clockMinutes: state.clock,
+        // The opening was written for the moment the world began; the clock shows how long ago that was.
+        setting: { world: state.setting, opening: { ...state.opening, ...(state.startClock === undefined ? {} : { asOf: clockLabel(state.startClock) }) }, ...messageTravel(state) },
+        actor: { id: actor.id, name: actor.name, role: actor.role, pronouns: actor.pronouns ?? 'they/them', isPlayer: actor.isPlayer, money: actor.money, mood: actor.mood, incapacitated: actor.incapacitated, holding: [...Object.values(state.objects).filter(object => object.holderId === actor.id).map(object => ({ id: object.id, name: object.name, condition: object.condition })),
+                ...(state.entityPlaceIds[actor.placeId] ?? []).filter(id => state.entities[id].holderId === actor.id).map(id => ({ id, name: state.entities[id].name }))],
+            // The player votes with their own vote command; a ruling casts only a character's own vote.
+            ...(actor.isPlayer ? {} : openVotes(state, actor.id)) },
+        narrationVoice: actor.isPlayer ? 'second person ("you"), present tense' : `third person by name (${actor.name}), present tense`,
+        attempt,
+        // What the actor said here lately, word for word, for an act that writes or repeats it.
+        actorSaid: state.conversations.filter(conversation => conversation.placeId === actor.placeId).flatMap(conversation => conversation.lines)
+            .filter(line => line.speakerId === actor.id).sort((left, right) => left.seq - right.seq).slice(-3).map(line => ({ at: clockLabel(line.at), text: line.text })),
+        ...(finishing ? { finishing: { note: FINISHING_NOTE, ...finishing } } : {}),
+        scene,
+        ...moneyAt(state, actor.placeId, actor.id),
+        ...deadlinesNow(state, true),
+        ...promisesAt(state, actor.placeId),
+        kinds: kindsInScope(state, actor.placeId),
+        ...writeRule(state),
+        requests: relevantRequests(state.requests.filter(request => request.senderId === actor.id
+            && request.knownTo.includes(actor.id) && scene.people.some(person => person.id === request.receiverId)))
+            .map(request => ({ id: request.id, toId: request.receiverId,
+            topic: request.topic, status: request.status })),
+        recentHere: recentEventsAt(state, actor.placeId, 8, null),
+        // Serious events already listed here are not listed twice.
+        recentSerious: recentImportant(state, 8, recentSeqsAt(state, actor.placeId, 8)),
+        world: worldDirectory(state, actor.placeId),
+        possiblePerceiverIds: scene.people.map(person => person.id),
+        presentCharacterIds: scene.people.filter(person => !state.people[person.id].isPlayer && !person.incapacitated).map(person => person.id),
+        ...(previousErrors.length === 0 ? {} : { previousErrors: [...previousErrors] }),
+    }, REFEREE_INPUT_BUDGET, refereeTrim(state, keeps, close), close, keeps);
+}
+// The open promises of the people where a ruling happens, so what they do keeps or breaks them knowingly.
+function promisesAt(state, placeId) {
+    const here = new Set(peopleAt(state, placeId));
+    const promises = Object.values(state.people).flatMap(person => person.commitments.filter(commitment => commitment.status === 'open'
+        && (here.has(person.id) || here.has(commitment.toId))).map(commitment => ({ by: person.name, to: personLabel(state, commitment.toId), text: commitment.text,
+        ...(commitment.dueAt === null ? {} : { due: clockLabel(commitment.dueAt) }) }))).slice(-MIND_SLICE);
+    return promises.length === 0 ? {} : { promises };
+}
+// The money at stake where a ruling happens, in the world's unit: the purses of the actor and of people
+// there, and the accounts kept apart from anyone's purse, with who may move each.
+function moneyAt(state, placeId, actorId) {
+    if (state.currency === null)
+        return {};
+    const purses = Object.values(state.people).filter(person => person.money !== null && person.departed === undefined
+        && (person.id === actorId || person.placeId === placeId && person.away === undefined)).map(person => ({ id: person.id, name: person.name, balance: person.money }));
+    const accounts = Object.values(state.accounts ?? {}).map(account => ({ id: account.id, name: account.name, balance: account.balance,
+        movedBy: account.holderId === null ? 'the world\'s own rules' : personLabel(state, account.holderId) }));
+    return purses.length + accounts.length === 0 ? {} : { money: { unit: state.currency.name, balances: [...purses, ...accounts] } };
+}
+// The things an actor holds, those their last act concerned, and the newest things in the hands of the
+// people they deal with here stay in a ruling's view longest, so it can read and hand on what is in play.
+function actorKeeps(state, actorId, close) {
+    const last = [...state.events].reverse().find(event => event.actorId === actorId && event.thingIds !== undefined);
+    const dealing = (state.entityPlaceIds[state.people[actorId].placeId] ?? []).filter(id => {
+        const holderId = state.entities[id].holderId;
+        return holderId !== null && holderId !== actorId && close.has(holderId);
+    }).slice(-MIND_SLICE);
+    return new Set([...Object.values(state.entities).filter(entity => entity.holderId === actorId).map(entity => entity.id), ...(last?.thingIds ?? []), ...dealing]);
+}
+// A due happening is carried out as its world wrote it, and one that comes back is new each time.
+const HAPPENING_NOTE = 'It happens now, as written: show every consequence it names, reaching the people it would reach.';
+const RECURRING_NOTE = 'This time is not like the earlier times.';
+// A later look at a serious act's consequences restates the act; it must not rule the act again.
+const AFTERMATH_NOTE = 'This already happened: rule only what has changed since because of it.';
+// A problem nobody has acted on for a while goes on by itself.
+const STALL_NOTE = 'Nobody has acted on this since about.since: rule how it has gone on by itself since, better, worse or settled; say what is new.';
+const FINISHING_NOTE = 'This act began at begunAt and its time has now passed, but the scene changed meanwhile as changed says. Rule it as done, on the scene as it is now.';
+// In a world where messages take time, everyone knows how they go and how long they take.
+function messageTravel(state) {
+    return state.messageTravel ? { messages: `Sent ${state.messageTravel.how}; each arrives about ${state.messageTravel.minutes} minutes after it is sent.` } : {};
+}
+// What a happening concerns, by id, name and kind.
+function concerned(state, id) {
+    const entity = state.entities[id];
+    if (entity)
+        return { id, name: entity.name, kind: state.kinds[entity.kindId]?.name ?? entity.kindId };
+    if (state.objects[id])
+        return { id, name: state.objects[id].name, kind: 'Object' };
+    if (state.people[id])
+        return { id, name: state.people[id].name, kind: 'Person' };
+    if (state.places[id])
+        return { id, name: state.places[id].name, kind: 'Place' };
+    const tension = state.tensions.find(candidate => candidate.id === id);
+    // A problem says since when it has stood as it is.
+    return tension ? { id, name: tension.title, kind: 'Problem', since: clockLabel(tension.changedAt) } : undefined;
+}
+// A happening that comes back remembers its last few times, so each one can be new.
+export function earlierTimes(state, sourceSeq) {
+    const earlier = [];
+    for (let seq = sourceSeq; seq > 0 && earlier.length < 3;) {
+        const before = state.events.find(event => event.seq === seq);
+        if (!before || before.kind !== 'world')
+            break;
+        earlier.push({ at: clockLabel(before.at), what: before.observed ?? before.summary });
+        seq = before.causeSeq ?? 0;
+    }
+    return earlier;
+}
+// A world happening that fell due: an arrival, a spreading fire, a storm, a delivery.
+export function gameMasterWorldInput(state, happening, previousErrors = [], _fitted = true, focusIds = []) {
+    const scene = describeScene(state, happening.placeId, null);
+    const cause = state.events.find(event => event.seq === happening.sourceSeq);
+    const about = happening.targetId ? concerned(state, happening.targetId) : undefined;
+    const earlier = happening.everyMinutes === undefined ? [] : earlierTimes(state, happening.sourceSeq);
+    return fitInput({
+        phase: 'world',
+        clock: clockLabel(state.clock),
+        clockMinutes: state.clock,
+        // The opening was written for the moment the world began; the clock shows how long ago that was.
+        setting: { world: state.setting, opening: { ...state.opening, ...(state.startClock === undefined ? {} : { asOf: clockLabel(state.startClock) }) }, ...messageTravel(state) },
+        happening: happening.intent,
+        // What the world's own data says this happening has made true; the narration agrees with it.
+        ...(happening.alreadyTrue && happening.alreadyTrue.length > 0 ? { nowTrue: [...happening.alreadyTrue] } : {}),
+        happeningNote: happening.id?.startsWith('aftermath-') ? AFTERMATH_NOTE : happening.id?.startsWith('stall-check') ? STALL_NOTE : happening.everyMinutes === undefined ? HAPPENING_NOTE : `${HAPPENING_NOTE} ${RECURRING_NOTE}`,
+        // What a happening concerns, such as the fire a danger check is about or the expiry a deadline made.
+        ...(about === undefined ? {} : { about }),
+        ...(happening.everyMinutes === undefined ? {} : { recurring: { everyMinutes: happening.everyMinutes, earlier } }),
+        cause: cause ? { at: clockLabel(cause.at), summary: cause.summary } : null,
+        narrationVoice: 'third person, present tense; nobody here is "you"',
+        scene,
+        ...moneyAt(state, happening.placeId, null),
+        ...deadlinesNow(state, true),
+        ...promisesAt(state, happening.placeId),
+        kinds: kindsInScope(state, happening.placeId),
+        ...writeRule(state),
+        // The cause is its own field, so it is left out of the recent events here.
+        recentHere: recentEventsAt(state, happening.placeId, 8, null, happening.sourceSeq),
+        recentSerious: recentImportant(state, 8, recentSeqsAt(state, happening.placeId, 8)),
+        world: worldDirectory(state, happening.placeId),
+        possiblePerceiverIds: scene.people.map(person => person.id),
+        presentCharacterIds: scene.people.filter(person => !state.people[person.id].isPlayer && !person.incapacitated).map(person => person.id),
+        ...(previousErrors.length === 0 ? {} : { previousErrors: [...previousErrors] }),
+    }, REFEREE_INPUT_BUDGET, refereeTrim(state, new Set([...focusIds, ...(happening.targetId ? [happening.targetId] : [])]), new Set([...focusIds, ...(happening.targetId ? [happening.targetId] : [])])), new Set([...focusIds, ...(happening.targetId ? [happening.targetId] : [])]));
+}
+// What weighs on a person right now: the serious things they saw, noticed or were told lately.
+export function pressingMatters(state, person, limit) {
+    return pressingOf(state, person, limit)
+        .map(memory => ({ when: clockLabel(memory.at), minutesAgo: Math.max(0, state.clock - memory.at), text: memory.text }));
+}
+function pressingOf(state, person, limit) {
+    const unresolved = new Set(state.events.filter(event => event.effects.some(effect => {
+        if (effect.kind === 'place.condition')
+            return effect.add !== null && effect.aspect !== undefined
+                && state.places[effect.placeId]?.conditionAspects[effect.aspect]?.changedSeq === event.seq;
+        if (effect.kind === 'person.condition')
+            return effect.condition !== null && state.people[effect.personId]?.conditionChangedSeq === event.seq;
+        return false;
+    })).map(event => event.seq));
+    return pressingMemories(state, person, limit, unresolved);
+}
+// The latest pressing memories by time, whatever order a load brought them in.
+function pressingMemories(state, person, limit, unresolved) {
+    return person.memories
+        .filter(memory => memory.importance >= PRESSING_IMPORTANCE && (memory.at >= state.clock - PRESSING_MINUTES || unresolved.has(memory.eventSeq)))
+        .sort((left, right) => left.at - right.at)
+        .slice(-limit);
+}
+export function myMovements(state, person, limit) {
+    const moves = state.events
+        .filter(event => event.effects.some(effect => effect.kind === 'move' && effect.personId === person.id))
+        .slice(-limit)
+        .map((event) => {
+        const move = event.effects.find(effect => effect.kind === 'move' && effect.personId === person.id);
+        return `${clockLabel(event.at)}: went to ${move.kind === 'move' ? placeLabel(state, move.placeId) : ''}`;
+    });
+    return [...moves, `${clockLabel(state.clock)}: now in ${placeLabel(state, person.placeId)}`];
+}
+// A text field keeps its newest items until its size budget is spent, so its size stays flat as a
+// world ages and its lines grow longer. Items arrive oldest first; the newest one always fits.
+const FIELD_BUDGET = { conversation: 2400, myRecentLines: 1800, memories: 2400, recentlySeen: 1000, pressing: 1200, summaries: 1200 };
+// A summary card keeps its opening, most weighty lines within this many characters, so one always fits.
+const SUMMARY_CARD_TEXT = 1000;
+// Fields that tell the same kind of thing share one size, so a person with more pressing news or
+// more heard talk recalls fewer older things instead of getting a longer input as the world ages.
+const HISTORY_BUDGET = 4400;
+const TALK_BUDGET = 2600;
+const OWN_LINES_ROOM = 600;
+// The newest items that fit. The first field of a group keeps at least one item; later fields
+// get only the room the group has left.
+// The first items that fit, in order.
+function firstWithinBudget(items, budget) {
+    const kept = [];
+    let used = 0;
+    for (const item of items) {
+        const size = JSON.stringify(item).length + 1;
+        if (used + size > budget)
+            break;
+        kept.push(item);
+        used += size;
+    }
+    return kept;
+}
+function withinBudget(items, budget, keepOne = true) {
+    const kept = [];
+    let used = 0;
+    for (const item of [...items].reverse()) {
+        const size = JSON.stringify(item).length + 1;
+        if ((kept.length > 0 || !keepOne) && used + size > budget)
+            break;
+        kept.unshift(item);
+        used += size;
+    }
+    return kept;
+}
+// Each model call sees a window of the world of one size, however much the world holds. When an
+// input runs over, the least needed lists give up items in turn, tier by tier, until it fits.
+const CHARACTER_INPUT_BUDGET = 10_000;
+const REFEREE_INPUT_BUDGET = 12_000;
+function fitInput(input, budget, tiers, close = new Set(), things = new Set()) {
+    // Leave room for the bounded lookup result on a follow-up transmission.
+    const maximum = decisionInputBudget(input, budget) - 512;
+    budget -= 512;
+    const fitted = structuredClone(input);
+    const priority = selectModelPeople(fitted, close);
+    syncModelPeople(fitted);
+    let size = JSON.stringify(fitted).length;
+    if (size <= budget)
+        return fitted;
+    const listAt = (path) => {
+        let node = fitted;
+        for (const key of path)
+            node = node !== null && typeof node === 'object' ? node[key] : undefined;
+        return Array.isArray(node) ? node : null;
+    };
+    const kept = (item) => {
+        const id = String(item?.id);
+        return priority.has(id) || things.has(id);
+    };
+    for (const tier of tiers) {
+        let removed = true;
+        while (size > budget && removed) {
+            removed = false;
+            for (const rule of tier) {
+                if (size <= budget)
+                    break;
+                const list = listAt(rule.path);
+                if (list === null || list.length <= (rule.keep ?? 0))
+                    continue;
+                let index = rule.drop === 'first' ? 0 : rule.drop === 'last' ? list.length - 1 : rule.drop(list);
+                // A rule may find nothing it is allowed to drop.
+                if (index < 0)
+                    continue;
+                if (kept(list[index])) {
+                    index = list.length - 1;
+                    while (index >= 0 && kept(list[index]))
+                        index -= 1;
+                }
+                if (index < 0)
+                    continue;
+                list.splice(index, 1);
+                fitted.view = MODEL_VIEW_NOTE;
+                syncModelPeople(fitted);
+                size = JSON.stringify(fitted).length;
+                removed = true;
+            }
+        }
+    }
+    compactModelInput(fitted, budget, priority, maximum, things);
+    syncModelPeople(fitted);
+    return fitted;
+}
+// Things at the place that changed longest ago go first; things with no place stay longer, and what
+// the actor holds or just dealt with stays longest.
+function stalestThing(state, kept = new Set()) {
+    const lastChanged = (id) => {
+        const entity = state.entities[id];
+        if (entity === undefined)
+            return 0;
+        return Math.max(entity.introducedSeq, ...Object.values(entity.properties).map(slot => slot.changedSeq), ...Object.values(entity.relations).map(slot => slot.changedSeq));
+    };
+    return (items) => {
+        let chosen = 0;
+        let chosenKey = [Infinity, Infinity];
+        items.forEach((item, index) => {
+            const id = item.id;
+            const key = [kept.has(id) ? 2 : state.entities[id]?.placeId === null ? 1 : 0, lastChanged(id)];
+            if (key[0] < chosenKey[0] || (key[0] === chosenKey[0] && key[1] < chosenKey[1])) {
+                chosen = index;
+                chosenKey = key;
+            }
+        });
+        return chosen;
+    };
+}
+// Settled asks go before open or refused ones, oldest first within each.
+function settledAskFirst(items) {
+    const settled = items.findIndex(item => !['open', 'refused'].includes(item.status));
+    return settled >= 0 ? settled : 0;
+}
+// People known but not here go first from a directory, the most recently listed first; someone this
+// person deals with is never dropped, so their name and pronouns stay known.
+function elsewhereFirst(kept) {
+    return (items) => {
+        for (let index = items.length - 1; index >= 0; index -= 1) {
+            const entry = items[index];
+            if (entry.here !== true && !kept.has(entry.id))
+                return index;
+        }
+        return -1;
+    };
+}
+// The people a person deals with: those here, those they talk with, feel about, ask or owe, and whom their plan is about.
+function dealtWith(state, person) {
+    return new Set([...peopleAt(state, person.placeId), ...Object.keys(person.relationships), ...person.commitments.map(commitment => commitment.toId),
+        ...(person.plan?.targetId ? [person.plan.targetId] : []),
+        ...state.requests.filter(request => request.senderId === person.id || request.receiverId === person.id).flatMap(request => [request.senderId, request.receiverId]),
+        ...state.conversations.filter(conversation => conversation.placeId === person.placeId && conversation.endedAt === null).flatMap(conversation => conversation.participantIds)]);
+}
+// The people someone is dealing with now: the player, whom the moment is about, who spoke or was spoken
+// to in the last lines of their talk here, their plan's person and those they have an open ask with.
+const TALK_LINES_IN_VIEW = 6;
+function inTalkWith(state, person, focusIds) {
+    return new Set([...focusIds.filter((id) => typeof id === 'string'), person.id, state.playerId, ...(person.plan?.targetId ? [person.plan.targetId] : []),
+        ...state.conversations.filter(conversation => conversation.placeId === person.placeId && conversation.endedAt === null && conversation.participantIds.includes(person.id))
+            .flatMap(conversation => conversation.lines.slice(-TALK_LINES_IN_VIEW).flatMap(line => [line.speakerId, ...line.toIds])),
+        ...state.requests.filter(request => request.status === 'open' && (request.senderId === person.id || request.receiverId === person.id)).flatMap(request => [request.senderId, request.receiverId])]);
+}
+// In a crowded room the people least bound to the moment leave the scene first, the latest listed
+// first; the directory still names everyone here, and at least four stay in full.
+const SCENE_PEOPLE_KEPT = 4;
+function leastInvolved(close, isPerson = () => true) {
+    return (items) => {
+        for (let index = items.length - 1; index >= 0; index -= 1) {
+            const id = items[index].id;
+            if (!close.has(id) && isPerson(id))
+                return index;
+        }
+        return -1;
+    };
+}
+// Weighing the player's words sees an input of one size, however full the room: people elsewhere give
+// way first, then the things changed longest ago and the people here the player deals with least.
+const SPEECH_INPUT_BUDGET = 3_000;
+// The opening gives the words their stakes; held to a bound, it never crowds out the people who hear them.
+const SPEECH_SITUATION = 600;
+const SPEECH_STAKES = 300;
+export function speechSetting(state) {
+    return { title: state.opening.title, situation: state.opening.situation.slice(0, SPEECH_SITUATION), stakes: state.opening.stakes.slice(0, SPEECH_STAKES) };
+}
+export function fitSpeechInput(state, input, close, held) {
+    return fitInput(input, SPEECH_INPUT_BUDGET, [[{ path: ['elsewhere'], drop: 'last' }],
+        [{ path: ['things'], drop: stalestThing(state, held), keep: 4 }, { path: ['listeners'], drop: leastInvolved(close), keep: SCENE_PEOPLE_KEPT }]], close);
+}
+function characterTrim(state, kept = new Set(), close = new Set()) {
+    return [
+        [{ path: ['landmarks'], drop: 'first', keep: 1 }, { path: ['myEarlierActivities'], drop: 'first', keep: 2 }, { path: ['myRecentLines'], drop: 'first', keep: 1 }, { path: ['myMovements'], drop: 'first', keep: 1 }],
+        [{ path: ['scene', 'people'], drop: leastInvolved(close), keep: SCENE_PEOPLE_KEPT },
+            { path: ['scene', 'entities'], drop: stalestThing(state), keep: 2 }, { path: ['requests'], drop: settledAskFirst, keep: 2 }, { path: ['beliefs'], drop: 'last', keep: 1 },
+            { path: ['recentlySeen'], drop: 'first', keep: 2 }, { path: ['directory', 'people'], drop: elsewhereFirst(kept), keep: 0 }],
+        [{ path: ['conversation'], drop: 'first', keep: 2 }, { path: ['scene', 'objects'], drop: 'first', keep: 2 }, { path: ['stances'], drop: 'last', keep: 1 }, { path: ['commitments'], drop: 'last', keep: 1 },
+            // What this person recalls is cut late, least bound to the moment first, and a little always stays.
+            { path: ['memories'], drop: 'last', keep: 2 }, { path: ['summaries'], drop: 'last', keep: 1 }],
+        [{ path: ['pressing'], drop: 'first', keep: 1 }],
+    ];
+}
+function refereeTrim(state, kept = new Set(), close = new Set()) {
+    return [
+        [{ path: ['world', 'facts'], drop: 'first' }, { path: ['world', 'objects'], drop: 'first' }],
+        // A ruling names anyone present who notices from the ids it is given; the crowd's details give way.
+        [{ path: ['scene', 'people'], drop: leastInvolved(close), keep: SCENE_PEOPLE_KEPT }, { path: ['world', 'people'], drop: leastInvolved(close), keep: SCENE_PEOPLE_KEPT },
+            { path: ['money', 'balances'], drop: leastInvolved(close, id => state.people[id] !== undefined), keep: SCENE_PEOPLE_KEPT },
+            { path: ['scene', 'entities'], drop: stalestThing(state, kept), keep: 2 }, { path: ['recentHere'], drop: 'first', keep: 2 }, { path: ['world', 'tensions'], drop: 'first', keep: 1 }],
+        [{ path: ['requests'], drop: settledAskFirst, keep: 2 }, { path: ['scene', 'objects'], drop: 'first', keep: 2 }, { path: ['world', 'elsewhere'], drop: 'first' }, { path: ['promises'], drop: 'first', keep: 2 }],
+        // The record of what really happened goes last, and its newest three stay.
+        [{ path: ['recentSerious'], drop: 'first', keep: 3 }],
+    ];
+}
+function spent(items) {
+    return items.reduce((total, item) => total + JSON.stringify(item).length + 1, 0);
+}
+// Each memory, line and plan appears once: pressing memories first, then the latest others, then
+// recalled older ones; the conversation, then the person's own lines elsewhere.
+export function characterMind(state, person, focusIds, shownElsewhere = {}) {
+    const scene = describeScene(state, person.placeId, person.id);
+    const relationships = Object.entries(person.relationships)
+        .filter(([id]) => state.people[id] && (scene.people.some(other => other.id === id) || person.memories.some(memory => memory.participantIds.includes(id))))
+        // Why their feelings last changed, so a confession or a betrayal is not forgotten.
+        .map(([id, relationship]) => ({ id, name: personLabel(state, id), trust: relationship.trust, warmth: relationship.warmth, ...(relationship.note ? { note: relationship.note } : {}) }));
+    const heard = heardLines(state, person.placeId, person.id, 12);
+    const trigger = shownElsewhere.line;
+    const triggerLine = trigger === undefined ? undefined
+        : [...heard].reverse().find(line => line.speakerId === trigger.speakerId && line.text === trigger.text);
+    // The conversation leaves room in the talk budget for at least the person's latest line elsewhere.
+    const conversation = withinBudget(heard.filter(line => line !== triggerLine).map(line => lineCard(state, line)), Math.min(FIELD_BUDGET.conversation, TALK_BUDGET - OWN_LINES_ROOM));
+    const heardSeqs = new Set(heard.map(line => line.seq));
+    // A line already in the conversation, or the one being answered, is not listed again as news.
+    const inTalk = new Set([...heard.slice(-conversation.length - (triggerLine ? 1 : 0)).map(line => line.seq), ...(triggerLine ? [triggerLine.seq] : [])]);
+    const pressing = pressingOf(state, person, 6).filter(memory => !inTalk.has(memory.eventSeq));
+    const pressingIds = new Set(pressing.map(memory => memory.id));
+    const latest = person.memories.filter(memory => !pressingIds.has(memory.id) && !inTalk.has(memory.eventSeq)).sort((left, right) => left.at - right.at).slice(-6);
+    const shownIds = new Set([...pressingIds, ...latest.map(memory => memory.id)]);
+    // History fills in order of urgency: pressing news, the last things seen, long-term summaries,
+    // then recalled older memories in whatever room is left.
+    const pressingCards = withinBudget(pressing.map(memory => ({ id: memory.id, when: clockLabel(memory.at), minutesAgo: Math.max(0, state.clock - memory.at), text: memory.text })), FIELD_BUDGET.pressing);
+    // The last things this person saw or was told, whatever the cues: nobody forgets the last hour.
+    const recentCards = withinBudget(latest.map(memory => ({ id: memory.id, when: clockLabel(memory.at), text: memory.text, evidence: memory.evidence?.kind ?? 'legacy' })), Math.min(FIELD_BUDGET.recentlySeen, HISTORY_BUDGET - spent(pressingCards)));
+    // Summaries come best first, so the budget keeps them from the front.
+    const summaryCards = withinBudget((person.summaries ?? []).filter(summary => summary.personId === person.id)
+        .map(summary => ({ summary, relevance: summary.participantIds.some(id => focusIds.includes(id))
+            || summary.placeIds.some(id => focusIds.includes(id)) ? 1 : 0 }))
+        .sort((left, right) => right.relevance - left.relevance || right.summary.importance - left.summary.importance
+        || right.summary.at - left.summary.at).slice(0, 3)
+        .map(({ summary }) => ({ id: summary.id, when: clockLabel(summary.at), text: summary.text.slice(0, SUMMARY_CARD_TEXT),
+        importance: summary.importance })).reverse(), Math.min(FIELD_BUDGET.summaries, HISTORY_BUDGET - spent(pressingCards) - spent(recentCards)), false).reverse();
+    // Recall reaches past the talk under way to older things.
+    const talkMemoryIds = person.memories.filter(memory => heardSeqs.has(memory.eventSeq)).map(memory => memory.id);
+    // Recalled memories come best first; a cut takes the least bound to the moment, never the oldest first.
+    const memoryCards = firstWithinBudget(recallMemories(state, person, focusIds, 8, new Set([...shownIds, ...talkMemoryIds]), true).map(memory => ({ id: memory.id, when: clockLabel(memory.at), text: memory.text, importance: memory.importance,
+        evidence: memory.evidence?.kind ?? 'legacy' })), Math.min(FIELD_BUDGET.memories, HISTORY_BUDGET - spent(pressingCards) - spent(recentCards) - spent(summaryCards)));
+    // The gravest things this person ever lived through stay with them, however long ago.
+    const listed = new Set([...shownIds, ...memoryCards.map(card => card.id)]);
+    const landmarkCards = person.memories.filter(memory => memory.importance >= LANDMARK_IMPORTANCE && !listed.has(memory.id))
+        .sort((left, right) => right.importance - left.importance || right.at - left.at).slice(0, LANDMARKS).sort((left, right) => left.at - right.at)
+        .map(memory => ({ id: memory.id, when: clockLabel(memory.at), text: memory.text, importance: memory.importance, evidence: memory.evidence?.kind ?? 'legacy' }));
+    return {
+        setting: state.setting,
+        ...messageTravel(state),
+        identity: { id: person.id, name: person.name, role: person.role, pronouns: person.pronouns ?? 'they/them',
+            character: person.character ?? { voice: person.persona, values: [], redLines: [], privateConcerns: [] },
+            mood: person.mood, condition: person.condition ?? null, held: person.held ? person.held.reason : null, money: person.money,
+            blocked: blockedActionKinds(state, person.id) },
+        goals: person.goals.filter(goal => goal.status === 'active').slice(-MIND_SLICE).map(goal => ({ id: goal.id, text: goal.text })),
+        relationships,
+        pressing: pressingCards,
+        memories: memoryCards,
+        summaries: summaryCards,
+        landmarks: landmarkCards,
+        recentlySeen: recentCards,
+        // Where this person has actually been, so they never claim to have been somewhere else.
+        myMovements: myMovements(state, person, 6),
+        // What they took up before their present activity and when, so hours of the same waiting are
+        // plain to them; the present one is the plan above.
+        myEarlierActivities: (person.planHistory ?? []).slice(0, person.plan ? -1 : undefined).map(item => ({ since: clockLabel(item.at), what: item.intent })),
+        beliefs: recallBeliefs(person, focusIds, 6).map(belief => ({ id: belief.id, subject: belief.subject, claim: belief.claim, source: belief.source.kind === 'told' ? `told by ${personLabel(state, belief.source.personId ?? '')}` : belief.source.kind })),
+        // What others have promised this person and not yet kept: what they are owed.
+        promisedToMe: Object.values(state.people).flatMap(other => other.id === person.id ? [] : other.commitments
+            .filter(commitment => commitment.toId === person.id && commitment.status === 'open' && (commitment.knownTo?.includes(person.id) ?? true))
+            .map(commitment => ({ other, commitment })))
+            .sort((left, right) => left.commitment.madeAt - right.commitment.madeAt).slice(-MIND_SLICE)
+            .map(({ other, commitment }) => ({ id: commitment.id, by: other.name, text: commitment.text, due: commitment.dueAt === null ? null : clockLabel(commitment.dueAt) })),
+        commitments: person.commitments.filter(commitment => commitment.status === 'open')
+            .sort((left, right) => (left.dueAt ?? Infinity) - (right.dueAt ?? Infinity) || left.madeAt - right.madeAt).slice(0, MIND_SLICE)
+            .map(commitment => ({ id: commitment.id, to: personLabel(state, commitment.toId), text: commitment.text, due: commitment.dueAt === null ? null : clockLabel(commitment.dueAt),
+            ...(commitment.dueAt === null ? {} : commitment.dueAt >= state.clock ? { minutesLeft: commitment.dueAt - state.clock } : { minutesPast: state.clock - commitment.dueAt }) })),
+        ...deadlinesNow(state),
+        ...ownPapers(state, person.id),
+        ...papersInMind(state, person, focusIds),
+        ...awakeSince(state, person),
+        requests: relevantRequests(state.requests.filter(request => request.knownTo.includes(person.id)))
+            .map(request => ({ id: request.id, fromId: request.senderId, toId: request.receiverId,
+            topic: request.topic, status: request.status, ...(request.answer && request.senderId === person.id ? { answer: request.answer.text } : {}),
+            // How long one's own open request has waited, so hours of waiting are plain.
+            ...(request.senderId === person.id && request.status === 'open' && request.openedAt !== undefined ? { waitingMinutes: state.clock - request.openedAt } : {}) })),
+        stances: state.stances.filter(stance => stance.personId === person.id)
+            .sort((left, right) => Number(scene.people.some(other => other.id === right.actorId)) - Number(scene.people.some(other => other.id === left.actorId))
+            || right.changedSeq - left.changedSeq).slice(0, MIND_SLICE)
+            .map(stance => ({ actorId: stance.actorId, status: stance.status, sourceSeq: stance.sourceSeq })),
+        plan: person.plan ? { intent: person.plan.intent, due: clockLabel(person.plan.dueAt), placeId: person.plan.placeId, targetId: person.plan.targetId } : null,
+        scene,
+        conversation,
+        myRecentLines: withinBudget(recentLinesBy(state, person.id, 12).filter(line => !heardSeqs.has(line.seq)).map(line => line.text), Math.min(FIELD_BUDGET.myRecentLines, TALK_BUDGET - spent(conversation))),
+        clock: clockLabel(state.clock),
+    };
+}
+function knownPeople(state, person) {
+    const ids = new Set(Object.keys(person.relationships));
+    // Only those really here are known by being here: not someone away, nor someone who left the story.
+    for (const other of Object.values(state.people))
+        if (other.placeId === person.placeId && other.away === undefined && other.departed === undefined)
+            ids.add(other.id);
+    for (const memory of person.memories)
+        for (const id of memory.participantIds)
+            ids.add(id);
+    for (const belief of person.beliefs)
+        if (belief.source.personId !== null)
+            ids.add(belief.source.personId);
+    for (const commitment of person.commitments)
+        ids.add(commitment.toId);
+    if (person.plan?.targetId)
+        ids.add(person.plan.targetId);
+    for (const conversation of state.conversations) {
+        if (!conversation.participantIds.includes(person.id))
+            continue;
+        for (const id of conversation.participantIds)
+            ids.add(id);
+    }
+    ids.delete(person.id);
+    return ids;
+}
+// Resolve model-supplied references, never words in an action. Unknown and ambiguous names
+// have the same result, so asking cannot expose an identity outside this role's knowledge.
+export function modelContextPeople(state, actorId, phase, input, requested) {
+    const actor = actorId === null ? undefined : state.people[actorId];
+    const referee = phase === 'attempt' || phase === 'world';
+    const placeId = input.scene?.id ?? actor?.placeId;
+    const allowed = referee && placeId ? new Set(worldDirectory(state, placeId).people.map(person => person.id))
+        : actor ? knownPeople(state, actor) : new Set();
+    if (actor)
+        allowed.add(actor.id);
+    const focusIds = [], unavailable = [];
+    for (const reference of requested) {
+        const matches = Object.values(state.people).filter(person => allowed.has(person.id) && (person.id === reference || person.name === reference));
+        if (matches.length === 1)
+            focusIds.push(matches[0].id);
+        else
+            unavailable.push(reference);
+    }
+    return { focusIds: [...new Set(focusIds)], unavailable };
+}
+function knownPlaces(state, person) {
+    const ids = new Set([person.placeId, ...state.places[person.placeId].connections]);
+    for (const memory of person.memories)
+        if (memory.placeId !== null)
+            ids.add(memory.placeId);
+    if (person.plan?.placeId)
+        ids.add(person.plan.placeId);
+    return ids;
+}
+function spokenTo(state, trigger) {
+    for (const event of [...state.events].reverse()) {
+        const said = event.effects.find(effect => effect.kind === 'say' && effect.personId === trigger.actorId && effect.text === trigger.text);
+        if (said?.kind === 'say')
+            return said.toIds.map(id => personLabel(state, id));
+    }
+    return [];
+}
+export function characterReactionInput(state, person, trigger, _fitted = true, previousErrors = [], focusIds = []) {
+    const actorName = trigger.actorId ? personLabel(state, trigger.actorId) : 'The world';
+    const noticed = trigger.kind === 'nearby';
+    const peopleInScope = knownPeople(state, person);
+    // Someone away for a while is not here, wherever they left from.
+    const present = (other) => other.placeId === person.placeId && other.away === undefined && other.departed === undefined;
+    return fitInput({
+        phase: 'reaction',
+        ...(previousErrors.length === 0 ? {} : { previousErrors: [...previousErrors] }),
+        ...characterMind(state, person, [...(trigger.actorId === null ? [person.placeId] : [trigger.actorId, person.placeId]), ...(trigger.thingIds ?? [])], trigger.kind === 'speech' ? { line: { speakerId: trigger.actorId, text: trigger.text } } : {}),
+        happened: noticed
+            ? { kind: 'noticed-from-nearby', by: null, byId: null, text: trigger.text, narration: null, from: trigger.noticedFrom ?? null }
+            : { kind: trigger.kind, by: actorName, byId: trigger.actorId, text: trigger.text, narration: trigger.narration, pressure: trigger.pressure ?? null,
+                // Whom the line was said to, since the line itself is not repeated in the conversation.
+                ...(trigger.kind === 'speech' ? { to: spokenTo(state, trigger) } : {}) },
+        // A vote is offered only in answer to a moment about it, so words about something else cast none.
+        ...openVotes(state, person.id, new Set(trigger.thingIds ?? [])),
+        playerId: state.playerId,
+        playerName: peopleInScope.has(state.playerId) ? personLabel(state, state.playerId) : null,
+        playerPronouns: peopleInScope.has(state.playerId) ? state.people[state.playerId]?.pronouns ?? 'they/them' : null,
+        playerHere: state.people[state.playerId]?.placeId === person.placeId,
+        exits: state.places[person.placeId].connections.map(id => ({ id, name: state.places[id]?.name ?? id })),
+        directory: { people: Object.values(state.people).filter(other => peopleInScope.has(other.id)).map(other => ({ id: other.id, name: other.name,
+                pronouns: other.pronouns ?? 'they/them', role: present(other) ? other.role : null, here: present(other), ...silentSince(state, person.id, other.id) })) },
+    }, CHARACTER_INPUT_BUDGET, characterTrim(state, dealtWith(state, person), inTalkWith(state, person, [...focusIds, trigger.actorId])), inTalkWith(state, person, [...focusIds, trigger.actorId]));
+}
+// A deadline whose problem is already settled will not happen; it is no longer counted down to.
+export function avertedAhead(state, item) {
+    const settles = item.beat?.unless?.settled;
+    return settles !== undefined && state.tensions.some(tension => tension.id === settles && tension.status === 'settled');
+}
+// The world's public deadlines, counted from now: minutes left for those ahead, and minutes past for
+// those that went by in the last day, so no one speaks of a passed deadline as still to come.
+function deadlinesNow(state, withOutcome = false) {
+    const ahead = state.schedule.filter(item => item.kind === 'world' && item.beat?.deadline && !avertedAhead(state, item)).sort((left, right) => left.at - right.at).slice(0, 4)
+        .map(item => ({ what: item.intent, due: clockLabel(item.at), minutesLeft: Math.max(0, item.at - state.clock) }));
+    const past = (state.passedDeadlines ?? []).filter(entry => state.clock - entry.at <= 1440).slice(-3)
+        .map(entry => ({ what: entry.what, due: clockLabel(entry.at), minutesPast: state.clock - entry.at, ...(entry.averted ? { averted: true } : {}),
+        ...(withOutcome ? { outcome: entry.outcome } : {}) }));
+    return ahead.length + past.length === 0 ? {} : { deadlines: [...past, ...ahead] };
+}
+// Since when someone up a long day has been awake: since they last came back from rest, or since the story began.
+export function awakeSince(state, person) {
+    const since = person.restedAt ?? state.startClock ?? 0;
+    return state.clock - since >= LONG_DAY_MINUTES ? { awakeSince: clockLabel(since) } : {};
+}
+// The words of the papers this person wrote, the newest two, wherever the papers now lie.
+export function ownPapers(state, personId) {
+    const papers = (state.authoredIds?.[personId] ?? []).slice(-2).map(id => state.entities[id]).flatMap(entity => {
+        const slot = entity?.properties.body;
+        const perceived = slot?.knownTo.includes(personId) ? { name: entity.name, words: slot.value } : entity?.paperViews?.[personId];
+        return entity && typeof perceived?.words === 'string'
+            ? [{ id: entity.id, name: perceived.name, words: perceived.words.slice(0, OWN_PAPER_WORDS) }] : [];
+    });
+    return papers.length === 0 ? {} : { myPapers: papers };
+}
+const OWN_PAPER_WORDS = 800;
+// The words of the papers a moment concerns that this person knows, wherever they lie, so no one makes
+// up what a paper they know says. Those here are in the scene, and those they wrote are their own.
+export function papersInMind(state, person, focusIds) {
+    const own = new Set(state.authoredIds?.[person.id] ?? []);
+    const papers = [...new Set(focusIds)].flatMap(id => {
+        const entity = state.entities[id];
+        const words = entity?.properties.body;
+        return entity && entity.placeId !== person.placeId && !own.has(id) && entity.knownTo.includes(person.id) && typeof words?.value === 'string'
+            && words.knownTo.includes(person.id) && !sealedPaper(state.engine, entity) ? [{ id, name: entity.name, words: words.value.slice(0, OWN_PAPER_WORDS) }] : [];
+    }).slice(0, 2);
+    return papers.length === 0 ? {} : { papersInMind: papers };
+}
+// The votes this person may cast now: open decisions they are a member of and have not voted on,
+// among those a moment concerns when it names any.
+export function openVotes(state, personId, concerned) {
+    const votes = (state.openDecisionIds ?? []).filter(id => concerned === undefined || concerned.has(id)).map(id => state.entities[id])
+        .filter(entity => entity.members?.includes(personId) && entity.ballots?.[personId] === undefined && votingShut(state, entity, state.clock) === null).slice(0, 3)
+        .map(entity => {
+        const closesAt = entity.properties['closes-at']?.value;
+        const needed = entity.properties.needed?.value;
+        return { id: entity.id, question: String(entity.properties.question?.value ?? entity.name).slice(0, 300), needed: typeof needed === 'number' ? needed : null,
+            closes: typeof closesAt === 'number' ? clockLabel(closesAt) : null, count: entity.condition };
+    });
+    return votes.length === 0 ? {} : { votes };
+}
+// Someone who has left this person's last lines unanswered, since the first of them.
+function silentSince(state, personId, otherId) {
+    const since = unansweredSince(state, personId, otherId);
+    return since === null ? {} : { noAnswerSince: clockLabel(since) };
+}
+// The due plan is data: what the person meant to do, and how late it now is.
+export function characterPlanInput(state, person, plan, voteTurn = false, focusIds = []) {
+    const duePlan = typeof plan === 'string' ? { intent: plan } : plan;
+    // A decision is cued by where the person is, whom they are with, and whom their plan is about.
+    const mind = characterMind(state, person, [person.placeId, ...peopleAt(state, person.placeId).filter(id => id !== person.id),
+        ...(person.plan?.targetId ? [person.plan.targetId] : [])]);
+    // The due plan is the person's plan; it is listed once, with its place and person.
+    const current = mind.plan;
+    const due = duePlan !== null && current?.intent === duePlan.intent ? { ...duePlan, placeId: current.placeId, targetId: current.targetId } : duePlan;
+    if (due !== duePlan)
+        mind.plan = null;
+    const peopleInScope = knownPeople(state, person);
+    const here = (other) => other.placeId === person.placeId && other.away === undefined;
+    const placesInScope = knownPlaces(state, person);
+    return fitInput({
+        phase: 'plan',
+        ...mind,
+        duePlan: due,
+        // A member's turn to vote, when voting opens, is the decision in which they cast it.
+        ...(voteTurn ? openVotes(state, person.id) : {}),
+        directory: {
+            places: Object.values(state.places).filter(place => placesInScope.has(place.id)).map(place => ({ id: place.id, name: place.name })),
+            people: Object.values(state.people).filter(other => peopleInScope.has(other.id)).map(other => ({ id: other.id, name: other.name,
+                pronouns: other.pronouns ?? 'they/them', role: here(other) ? other.role : null, lastKnownPlaceId: here(other) ? other.placeId : null, ...silentSince(state, person.id, other.id) })),
+        },
+        playerId: state.playerId,
+    }, CHARACTER_INPUT_BUDGET, characterTrim(state, dealtWith(state, person), inTalkWith(state, person, [...focusIds, due?.targetId])), inTalkWith(state, person, [...focusIds, due?.targetId]));
+}
+export function characterMessageReplyInput(state, person, message, focusIds = []) {
+    const mind = characterMind(state, person, [message.fromId, person.placeId]);
+    const placesInScope = knownPlaces(state, person);
+    return fitInput({
+        phase: 'message-reply',
+        ...mind,
+        message: { fromId: message.fromId, from: personLabel(state, message.fromId), text: message.text },
+        directory: { places: Object.values(state.places).filter(place => placesInScope.has(place.id)).map(place => ({ id: place.id, name: place.name })),
+            ...(focusIds.length === 0 ? {} : { people: focusIds.filter(id => knownPeople(state, person).has(id)).map(id => ({ id, name: state.people[id].name })) }) },
+    }, CHARACTER_INPUT_BUDGET, characterTrim(state, dealtWith(state, person), inTalkWith(state, person, [...focusIds, message.fromId])), inTalkWith(state, person, [...focusIds, message.fromId]));
+}
+export function epilogueInput(state) {
+    const player = state.people[state.playerId];
+    const playerChoices = state.events.filter(event => event.actorId === state.playerId && (event.kind === 'speech' || event.kind === 'message' || event.kind === 'attempt')).slice(-24);
+    const choiceSeqs = new Set(playerChoices.map(event => event.seq));
+    const otherEvents = state.events.filter(event => !choiceSeqs.has(event.seq) && visibleTo(event, player.id)
+        && (event.importance >= 6 || event.kind === 'attempt' || event.kind === 'world')).slice(-(40 - playerChoices.length));
+    const keyEvents = [...playerChoices, ...otherEvents].sort((left, right) => left.seq - right.seq);
+    // From engine 40 the ending reads the chronicle of the whole story; the weightiest fifty, in order.
+    const chronicled = state.engine >= CHRONICLE_ENGINE
+        ? [...state.chronicle].sort((left, right) => right.importance - left.importance || right.seq - left.seq).slice(0, 50).sort((left, right) => left.seq - right.seq)
+            .map(entry => ({ kind: entry.kind, at: clockLabel(entry.at), place: placeLabel(state, entry.placeId), summary: entry.summary, outcome: entry.outcome, witnesses: [] }))
+        : null;
+    return fitInput({
+        phase: 'epilogue',
+        player: { name: player.name, role: player.role, pronouns: player.pronouns ?? 'they/them', place: placeLabel(state, player.placeId), money: player.money, incapacitated: player.incapacitated, forcedEnding: state.forcedEnding },
+        opening: state.opening,
+        tensions: state.tensions.flatMap(tension => {
+            if (!tension.playerView)
+                return [];
+            const { since: _since, latestAt: _latestAt, ...view } = tension.playerView;
+            return [view];
+        }),
+        ...knownVotes(state, player.id),
+        relationships: [],
+        whereabouts: Object.values(state.people).filter(person => person.id === player.id || person.placeId === player.placeId || state.sightings[person.id]).map(person => ({ name: person.name,
+            place: person.id === player.id || person.placeId === player.placeId ? placeLabel(state, person.placeId) : placeLabel(state, state.sightings[person.id].placeId),
+            mood: person.id === player.id || person.placeId === player.placeId ? person.mood : null,
+            condition: person.id === player.id || person.placeId === player.placeId ? person.condition ?? null : null,
+            incapacitated: person.id === player.id || person.placeId === player.placeId ? person.incapacitated : null })),
+        places: [{ name: state.places[player.placeId].name, conditions: [...state.places[player.placeId].conditions] }],
+        objects: Object.values(state.objects).filter(object => object.holderId === player.id || object.placeId === player.placeId
+            || (object.holderId !== null && knowsCustody(state, object, player.id))).map(object => ({ name: object.name,
+            condition: object.holderId === player.id || object.conditionKnownTo.includes(player.id) ? object.condition : 'unexamined',
+            where: object.holderId ? `with ${personLabel(state, object.holderId)}` : placeLabel(state, object.placeId) })),
+        commitments: Object.values(state.people).flatMap(person => person.commitments
+            .filter(commitment => person.id === player.id || commitment.toId === player.id).map(commitment => ({ person, commitment })))
+            .sort((left, right) => left.commitment.madeAt - right.commitment.madeAt).slice(-12)
+            .map(({ person, commitment }) => ({ by: person.name, to: personLabel(state, commitment.toId), text: commitment.text, status: commitment.status })),
+        keyEvents: chronicled ?? keyEvents.flatMap(event => {
+            const summary = observedSummary(event, player.id);
+            return summary === null ? [] : [{ kind: event.kind, at: clockLabel(event.at), place: event.nearbyIds.includes(player.id) && !witnessed(event, player.id) ? null : placeLabel(state, event.placeId),
+                    summary, outcome: event.observed === undefined ? event.outcome : null, witnesses: [] }];
+        }),
+        clock: clockLabel(state.clock),
+    }, REFEREE_INPUT_BUDGET, [[{ path: ['whereabouts'], drop: 'last', keep: 1 }, { path: ['objects'], drop: 'first' }, { path: ['keyEvents'], drop: 'first', keep: 8 }, { path: ['tensions'], drop: openFirst, keep: 1 }]]);
+}
+// Problems still open give way before settled ones, whose ends the ending tells; the oldest first within each.
+function openFirst(items) {
+    const open = items.findIndex(item => item.status === 'open');
+    return open >= 0 ? open : 0;
+}
+// The votes the player knows of: what was asked, what came of it, and the count. A counted vote's roll is
+// its public record; before the count the player knows only their own vote.
+function knownVotes(state, playerId) {
+    const votes = Object.values(state.entities).filter(entity => entity.members !== undefined && entity.knownTo.includes(playerId)).slice(-MIND_SLICE)
+        .map(entity => ({ name: entity.name, question: String(entity.properties.question?.value ?? entity.name).slice(0, 300), result: entity.result ?? null, count: entity.condition,
+        ballots: entity.members.filter(id => entity.ballots?.[id] !== undefined && (entity.result !== undefined || id === playerId))
+            .map(id => ({ name: personLabel(state, id), choice: entity.ballots[id] })) }));
+    return votes.length === 0 ? {} : { votes };
+}
+export const WORLD_PRINCIPLES = `People know only what they perceive, read or are told. They have their own aims, duties, feelings, and judgment. The setting decides what is physically and socially possible. An act can fail yet still cause a real result. A lasting result needs a typed change in state. Speech is a statement until evidence supports its claim. Describe only what a person in the scene can sense. Keep private thoughts and unseen causes in the objective record. Use ids for known people, things, places, kinds, problems. Let serious events affect later choices.`;
+function systemPrompt(role, schema, example) {
+    return `Role:\n${role}\nPrinciples:\n${WORLD_PRINCIPLES}\nFields:\n${responseFieldLines(schema)}\nExample:\n${example}`;
+}
+// One Game Master rules on both an actor's attempt and a happening that fell due; the input says which.
+export const GAME_MASTER_SYSTEM = systemPrompt('You are the Game Master of a living world. Rule on an actor\'s attempt, which reaches only who and what is here, or a due happening. Tell the actor what they perceive, including what they read or hear, word for word, and add no act, word or feeling they did not state. Represent each lasting result with the fitting kind and typed slots; request a kind when none fits.', attemptResponseSchema, '{"outcome":"partial","stateKindFit":"complete","stateUpdates":[{"kind":"entity.create","values":{"condition":"cracked","entityId":"lamp-id","initialProperties":{},"kindId":"item","name":"Oil lamp","personId":"actor-id","placeId":"place-id"}}]}');
+export const SPEECH_IMPACT_SYSTEM = systemPrompt('Assess one spoken line: its impact, the pressure it puts on listeners, and whether it carries. Never decide anyone\'s response.', speechImpactResponseSchema, '{"importance":3,"pressure":null,"loud":false}');
+export const CHARACTER_REACTION_SYSTEM = systemPrompt('You are the named character. Respond to happened.pressure when it exists, then choose what you say or do now. Say nothing you already said.', reactionResponseSchema, '{"say":"I need time to think.","act":null,"request":null,"endConversation":false,"plan":{"intent":"Check the figures alone","seenDoing":"reading at the window","placeId":null,"targetId":null,"inMinutes":40}}');
+export const CHARACTER_PLAN_SYSTEM = systemPrompt('You are the named character. What you were doing has ended, or something needs your decision. Live a whole day: eat, rest, go home when your day ends, and stop waiting when it brings nothing.', planResponseSchema, '{"action":"wait","placeId":null,"targetId":null,"text":null,"request":null,"nextPlan":{"intent":"Finish the report","seenDoing":"typing at the desk","placeId":null,"targetId":null,"inMinutes":45}}');
+export const CHARACTER_MESSAGE_SYSTEM = systemPrompt('You are the named character answering a private message. Treat its claims as claims, then decide whether to reply and what you believe.', messageReplyResponseSchema, '{"reply":null,"belief":null,"plan":{"intent":"Find the sender","seenDoing":"heading for the stairs","placeId":null,"targetId":null,"inMinutes":10}}');
+export const NARRATOR_EPILOGUE_SYSTEM = systemPrompt('Write an ending card from recorded outcomes. Use dry, kind humor and keep unresolved matters unresolved.', epilogueResponseSchema, '{"title":"The Long Afternoon","verdict":"The day ended.","highlights":["They went home."],"cast":[],"closing":"Tomorrow remained."}');