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

package/dist/simulation/living/inference.js

@@ -0,0 +1,576 @@
+// The model boundary. The app supplies a transport; the engine supplies prompts and
+// schemas, then validates every answer before it can touch the world.
+import { LIVING_ENGINE_VERSION, MAX_ADDED_LINE, MAX_ROLE, MAX_SPOKEN } from './types.js';
+import { neverHeld } from './shared-kinds.js';
+export const LIVING_INFERENCE_LIMITS = Object.freeze({
+    attempt: { maxTokens: 1200, timeoutMs: 60_000 },
+    world: { maxTokens: 1200, timeoutMs: 60_000 },
+    'speech-impact': { maxTokens: 200, timeoutMs: 20_000 },
+    reaction: { maxTokens: 500, timeoutMs: 30_000 },
+    reply: { maxTokens: 500, timeoutMs: 30_000 },
+    plan: { maxTokens: 500, timeoutMs: 30_000 },
+    'message-reply': { maxTokens: 500, timeoutMs: 30_000 },
+    epilogue: { maxTokens: 900, timeoutMs: 45_000 },
+    define: { maxTokens: 700, timeoutMs: 45_000 },
+});
+// JSON schemas for structured answers. They stay small so a modest model can fill
+// them, and every value they admit is re-checked against the world before commit.
+const str = (maxLength) => ({ type: 'string', minLength: 1, maxLength });
+const nullable = (schema) => ({ anyOf: [schema, { type: 'null' }] });
+const ids = (max) => ({ type: 'array', items: str(64), maxItems: max });
+export const GM_EFFECT_KINDS = ['move', 'take', 'drop', 'object.update', 'object.create', 'place.condition', 'place.create', 'person.create', 'money', 'transfer', 'relationship', 'belief', 'commitment', 'goal', 'mood', 'person.condition', 'hold', 'role', 'schedule', 'fact', 'tension.update', 'tension.create', 'incapacitate', 'message', 'entity.create', 'property.set', 'relation.set', 'request.open', 'person.leave', 'person.away', 'ballot'];
+const described = (schema, description) => ({ ...schema, description });
+// What each kind of typed change means. The fields block shows it beside the kind's fields.
+const EFFECT_MEANINGS = {
+    move: 'personId goes to the neighboring placeId.',
+    take: 'personId picks up or is handed objectId here.',
+    drop: 'The holder puts objectId down at placeId.',
+    'object.update': 'objectId\'s condition, holder targetId, place placeId or owner personId change; null keeps one.',
+    'object.create': 'A new object exists.',
+    'place.condition': 'A condition of a place changes.',
+    'place.create': 'A new place placeId, with name and text, joins its connections.',
+    'person.create': 'A new person personId, name and role, at placeId: anyone narrated who could be spoken to; person.away if only on a call.',
+    money: "personId's money changes by amount.",
+    transfer: 'amount passes from personId to targetId; null is outside the world.',
+    relationship: "A person's trust or warmth toward another changes.",
+    belief: 'A person now holds a claim as true.',
+    commitment: 'A person promises something to another.',
+    goal: 'A person takes up or drops an aim.',
+    mood: "A person's mood changes.",
+    'person.condition': "A person's visible physical state changes.",
+    hold: 'A person is kept where they are by another.',
+    role: "A person's role changes.",
+    schedule: 'A world happening, text, comes due at placeId in minutes; targetId is what it concerns.',
+    fact: 'A fact about the world changes.',
+    'tension.update': 'A problem changes status.',
+    'tension.create': 'A new problem opens.',
+    incapacitate: 'personId can no longer act, for the reason in text; a typed condition must now stop them.',
+    message: 'A written message reaches another person.',
+    'entity.create': 'A new thing entityId of kindId, named name, at placeId or no place (an agreement, debt, right or rumor); initialProperties holds its required values.',
+    'property.set': 'propertyId of entityId becomes value; text replaces it whole, null erases it; a time counts minutes as clockMinutes does.',
+    'relation.set': 'relationId of entityId links to targetId; null unlinks.',
+    'request.open': 'The actor personId asks targetId here to do text; priorId names a known request this repeats.',
+    'person.leave': 'personId leaves this world for good: quit, moved or died; text says why.',
+    'person.away': 'personId is away for minutes: home, asleep or an errand; text says where.',
+    ballot: 'The actor\'s own vote.',
+};
+// A world begun on engines 42 to 44 adds each write to a paper as a line of its own.
+const ADDED_LINE_MEANING = 'propertyId of entityId becomes value; text adds a line, null erases it; a time counts minutes as clockMinutes does.';
+const effectFields = {
+    personId: described(nullable(str(64)), 'Person whose state changes.'),
+    targetId: described(nullable(str(64)), 'Other person or entity id; null when none.'),
+    sourcePersonId: described(nullable(str(64)), 'Person who supplied the credited account; null for the sender’s own account.'),
+    placeId: described(nullable(str(64)), 'Place where this change occurs; null when it has no place.'),
+    objectId: described(nullable(str(64)), 'Existing object id; a written thing or token here counts as one.'),
+    tensionId: described(nullable(str(64)), 'Existing or new problem id.'),
+    name: described(nullable(str(120)), 'Name or stable aspect id for this change.'),
+    text: described(nullable(str(600)), 'Current value or short description; null to clear it.'),
+    condition: described(nullable(str(200)), 'Object condition; null when unchanged.'),
+    // A newcomer's role is offered only as long as the world accepts.
+    role: described(nullable(str(MAX_ROLE)), 'Their job or role in a few words, as anyone could tell, such as "site visitor"; never how they stand.'),
+    amount: described(nullable({ type: 'integer', minimum: -1_000_000_000, maximum: 1_000_000_000 }), 'Signed change in money.'),
+    trust: described(nullable({ type: 'integer', minimum: -40, maximum: 40 }), 'Change in trust.'),
+    warmth: described(nullable({ type: 'integer', minimum: -40, maximum: 40 }), 'Change in warmth.'),
+    minutes: described(nullable({ type: 'integer', minimum: 0, maximum: 100_000 }), 'Minutes until due or spent.'),
+    connections: described(nullable(ids(4)), 'Place ids connected to a new place.'),
+    participantIds: described(nullable(ids(6)), 'People involved in a problem.'),
+    status: described(nullable({ type: 'string', enum: ['open', 'settled'] }), 'Current problem status.'),
+    entityId: described(nullable(str(64)), 'Id of a typed entity.'),
+    kindId: described(nullable(str(64)), 'Kind id from the local kind definitions.'),
+    propertyId: described(nullable(str(64)), 'Property id defined by the entity kind.'),
+    relationId: described(nullable(str(64)), 'Relation id defined by the entity kind.'),
+    roleId: described(nullable(str(64)), 'Typed role id granted to this person; null removes an earlier role.'),
+    priorId: described(nullable(str(64)), 'Known request id when repeating or rewording that request; otherwise null.'),
+    value: described(nullable({ anyOf: [{ type: 'boolean' }, { type: 'number' }, str(2000)] }), 'Typed property value; use text for written content and null to clear it.'),
+    choice: described(nullable({ type: 'string', enum: ['yes', 'no', 'abstain'] }), 'The vote cast.'),
+    initialProperties: described({ type: 'object', additionalProperties: true }, 'Typed values written when the entity is created; include required values such as a document body.'),
+};
+const fieldsByEffect = {
+    move: ['personId', 'placeId'],
+    take: ['objectId', 'personId'],
+    drop: ['objectId', 'placeId'],
+    'object.update': ['objectId', 'condition', 'name', 'targetId', 'placeId', 'personId'],
+    'object.create': ['objectId', 'name', 'text', 'condition', 'placeId', 'targetId', 'personId'],
+    'place.condition': ['placeId', 'name', 'text'],
+    'place.create': ['placeId', 'name', 'text', 'connections'],
+    'person.create': ['personId', 'name', 'role', 'text', 'placeId'],
+    money: ['personId', 'amount'],
+    transfer: ['personId', 'targetId', 'amount'],
+    relationship: ['personId', 'targetId', 'trust', 'warmth'],
+    belief: ['personId', 'name', 'text'],
+    commitment: ['personId', 'targetId', 'text', 'minutes'],
+    goal: ['personId', 'name', 'text'],
+    mood: ['personId', 'text'],
+    'person.condition': ['personId', 'text'],
+    hold: ['personId', 'targetId', 'text'],
+    role: ['personId', 'text', 'roleId'],
+    schedule: ['personId', 'minutes', 'text', 'placeId', 'targetId'],
+    fact: ['name', 'text'],
+    'tension.update': ['tensionId', 'status', 'text'],
+    'tension.create': ['tensionId', 'name', 'text', 'participantIds'],
+    incapacitate: ['personId', 'text'],
+    message: ['personId', 'targetId', 'sourcePersonId', 'text'],
+    'entity.create': ['entityId', 'kindId', 'name', 'placeId', 'condition', 'personId', 'participantIds', 'initialProperties'],
+    'property.set': ['entityId', 'propertyId', 'value'],
+    'relation.set': ['entityId', 'relationId', 'targetId'],
+    'request.open': ['personId', 'targetId', 'text', 'priorId'],
+    'person.leave': ['personId', 'text'],
+    'person.away': ['personId', 'minutes', 'text'],
+    ballot: ['entityId', 'personId', 'choice'],
+};
+// Old events still decode through GmEffectRecord. New rulings use typed entities
+// for lasting things instead of open-ended prose records.
+const nonGmEffectKinds = new Set([
+    'fact', 'place.condition', 'object.create', 'money',
+    'belief', 'relationship', 'message', 'goal', 'mood', 'commitment', 'hold', 'person.condition',
+    'tension.create', 'tension.update', 'role',
+]);
+const requiredEffectValues = {
+    'place.create': ['name', 'text'], 'person.create': ['name', 'text'], money: ['amount'], transfer: ['amount'],
+    role: ['text'], schedule: ['text', 'minutes'], incapacitate: ['text'],
+    'entity.create': ['entityId', 'name', 'initialProperties'], 'property.set': ['entityId', 'propertyId'],
+    'relation.set': ['entityId', 'relationId'], 'request.open': ['text'], 'person.leave': ['personId', 'text'],
+    'person.away': ['personId', 'minutes', 'text'], ballot: ['entityId', 'choice'],
+};
+function effectField(kind, field) {
+    const source = effectFields[field];
+    if (field === 'initialProperties')
+        return source;
+    if (kind === 'schedule' && field === 'minutes')
+        return described({ type: 'integer', minimum: 1, maximum: 100_000 }, source.description);
+    if (kind === 'person.away' && field === 'minutes')
+        return described({ type: 'integer', minimum: 15, maximum: 1440 }, source.description);
+    if (kind === 'transfer' && field === 'amount')
+        return described({ type: 'number', exclusiveMinimum: 0, maximum: 1_000_000_000 }, source.description);
+    if (kind === 'money' && field === 'amount')
+        return described({ anyOf: [
+                { type: 'integer', minimum: -1_000_000_000, maximum: -1 },
+                { type: 'integer', minimum: 1, maximum: 1_000_000_000 },
+            ] }, source.description);
+    if (!requiredEffectValues[kind]?.includes(field))
+        return source;
+    const variants = source.anyOf;
+    return described(variants[0], source.description);
+}
+// The provider writes object keys in sorted order, so the first key written decides which
+// shape of a union remains possible. Each shape therefore names its kind first and keeps its
+// own fields under one key that sorts after it.
+export function kindFirst(container) {
+    return (arm) => {
+        const { kind, ...fields } = arm.properties;
+        return { type: 'object', additionalProperties: false, required: ['kind', container], properties: { kind,
+                [container]: { type: 'object', additionalProperties: false, required: arm.required.filter(name => name !== 'kind'), properties: fields } } };
+    };
+}
+// What a field means for one kind of change, where the shared meaning would mislead.
+const FIELD_MEANINGS = {
+    move: { personId: 'Person who goes.', placeId: 'Neighboring place the person goes to.' },
+    take: { personId: 'Person who takes the object.' },
+    drop: { placeId: 'Place where the object is put down.' },
+    'object.update': { condition: 'New condition; null when unchanged.', name: 'Condition side, such as damage; null for state.', targetId: 'New holder; null when unchanged.',
+        placeId: 'New place; null when unchanged.', personId: 'New owner; null when unchanged.' },
+    'place.create': { placeId: 'Id for the new place.', name: 'Name of the new place.', text: 'Short description of the new place.' },
+    'person.create': { personId: 'Id for the new person.', name: 'Full name of the new person.',
+        text: 'What brought them here and what they want now, in their own terms.', placeId: 'Place where the person appears.' },
+    money: { personId: 'Person whose money changes.' },
+    transfer: { personId: 'Who pays: a person or an account id; null when it comes from outside the world.', targetId: 'Who receives: a person or an account id; null when it leaves the world.',
+        amount: 'How much, in the world\'s money unit; parts of a unit are allowed.' },
+    schedule: { personId: 'Always null; people choose their own plans.', minutes: 'Minutes until it happens.', text: 'What will happen.',
+        placeId: 'Place where it happens.', targetId: 'Entity or person it concerns; null when none.' },
+    incapacitate: { personId: 'Person who can no longer act.', text: 'Why they cannot act.' },
+    'entity.create': { participantIds: 'A decision\'s voters; else null.', name: 'Name of the new thing.', placeId: 'Place where the new thing is; null when it belongs to no place, such as an agreement, a debt, a right, or a rumor.',
+        condition: 'How it is now, as anyone could see; null when it belongs to no place.', personId: 'Person here whose hand the act leaves it in; null for words on a wall, a board or a thing, and for anything that lies there.' },
+    'person.leave': { personId: 'Person who leaves.', text: 'Why and how they leave.' },
+    'person.away': { personId: 'Person who goes away for a while.', minutes: 'Minutes until they are back.', text: 'Where they go and why.' },
+    'request.open': { personId: 'Actor who makes the request.', targetId: 'Person here who receives the request.',
+        priorId: 'Known request id when repeating or rewording that request; otherwise null.', text: 'Action requested, with no answer implied.' },
+};
+const flatEffectArms = GM_EFFECT_KINDS.filter(kind => !nonGmEffectKinds.has(kind)).map(kind => {
+    const fields = fieldsByEffect[kind];
+    return {
+        type: 'object', additionalProperties: false, required: ['kind', ...fields],
+        properties: { kind: { const: kind, description: EFFECT_MEANINGS[kind] },
+            ...Object.fromEntries(fields.map(field => [field, FIELD_MEANINGS[kind]?.[field] === undefined ? effectField(kind, field)
+                    : described(effectField(kind, field), FIELD_MEANINGS[kind][field])])) },
+    };
+});
+export const gmEffectSchema = { anyOf: flatEffectArms.map(kindFirst('values')) };
+export function responseFieldLines(schema) {
+    const lines = Object.entries(schema.properties).map(([name, field]) => {
+        if (!field.description)
+            throw new Error(`Response field ${name} needs a description`);
+        return `${name}: ${field.description}`;
+    });
+    const unions = Object.values(schema.properties);
+    for (const arm of unions.flatMap(field => field.items?.anyOf ?? [])) {
+        const kind = arm.properties.kind?.const;
+        if (!kind || !arm.properties.kind?.description)
+            continue;
+        // Each kind of change is one line that names its own fields; their schema descriptions stay in the schema.
+        lines.push(`${kind}: ${arm.properties.kind.description}`);
+    }
+    return lines.join('\n');
+}
+// The provider emits object keys in sorted order. The names make that order the order of
+// reasoning: the written result comes first, then whether a kind fits, then the typed changes.
+// What a ruling may carry to the rooms around, each worded by the engine, so a notice never names anyone.
+export const SIGNAL_SENSES = ['sound', 'voices', 'shouting', 'scream', 'crash', 'bang', 'alarm', 'machinery', 'footsteps', 'music', 'loudspeaker', 'sight', 'light', 'smoke', 'burning', 'smell'];
+export const SIGNAL_NOTICES = {
+    sound: 'A sound reaches', voices: 'Voices carry', shouting: 'Shouting carries', scream: 'A scream carries', crash: 'A crash carries', bang: 'A bang carries',
+    alarm: 'An alarm sounds', machinery: 'The noise of machinery carries', footsteps: 'Running feet sound', music: 'Music carries', loudspeaker: 'A voice on a loudspeaker carries',
+    sight: 'A sight reaches', light: 'A light shows', smoke: 'Smoke drifts', burning: 'A smell of burning drifts', smell: 'A smell reaches',
+};
+export const attemptResponseSchema = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['narration', 'record', 'observed', 'perceivedBy', 'visibleObjectIds', 'visibleTensionIds', 'outcome', 'minutes', 'importance', 'reach', 'signalChannel', 'actionKind', 'reactorIds', 'settledTensionId', 'settlement', 'newTension', 'stateKindFit', 'stateNewKind', 'stateUpdates', 'thingIds'],
+    properties: {
+        narration: described(str(900), 'What the actor senses now, in the requested voice.'),
+        record: described(str(300), 'Objective result, hidden facts included.'),
+        observed: described(str(600), 'What onlookers here see: outward behavior only.'),
+        perceivedBy: described(ids(32), 'Present people who noticed it.'),
+        visibleObjectIds: described(ids(48), 'Local objects whose state onlookers see.'),
+        visibleTensionIds: described(ids(32), 'Local problems whose status onlookers see.'),
+        outcome: described({ type: 'string', enum: ['succeeded', 'partial', 'failed', 'impossible'] }, 'What happened to the attempt.'),
+        minutes: described({ type: 'integer', minimum: 0, maximum: 240 }, 'Game minutes it takes.'),
+        importance: described({ type: 'integer', minimum: 1, maximum: 10 }, 'Impact, 1 routine to 10 life changing.'),
+        reach: described({ type: 'string', enum: ['here', 'nearby', 'everywhere'] }, 'here, nearby (a shout, crash or smoke carries next door), or everywhere.'),
+        signalChannel: described(nullable({ type: 'string', enum: [...SIGNAL_SENSES] }), 'For nearby or everywhere, what carries to the rooms around; else null.'),
+        actionKind: described(nullable(str(64)), 'Act category from a local norm; null when none covers it.'),
+        reactorIds: described(ids(2), 'Up to two present people who react now.'),
+        settledTensionId: described(nullable(str(64)), 'Problem this resolves; else null.'),
+        settlement: described(nullable(str(600)), 'How that problem ended.'),
+        newTension: described(nullable({ type: 'object', additionalProperties: false, required: ['title', 'summary', 'participantIds', 'visible'], properties: { title: str(120), summary: str(600), participantIds: ids(6), visible: { type: 'boolean' } } }), 'A new problem; else null.'),
+        stateKindFit: described({ type: 'string', enum: ['not-needed', 'complete', 'missing'] }, 'complete: typed slots hold every lasting part; missing: no listed kind fits; not-needed: nothing lasting changes.'),
+        stateNewKind: described(nullable({ type: 'object', additionalProperties: false, required: ['id', 'name', 'meaning'], properties: { id: str(64), name: str(120), meaning: str(300) } }), 'When stateKindFit is missing: id, name and general meaning of a reusable kind.'),
+        stateUpdates: described({ type: 'array', items: gmEffectSchema, maxItems: 8 }, 'Typed changes that make the result last, each as its kind with fields in values.'),
+        thingIds: described(ids(8), 'Things here the act handles, uses or changes.'),
+    },
+};
+export function scopedAttemptResponseSchema(input) {
+    const kinds = input.kinds;
+    const kindIds = [...new Set(kinds.map(kind => kind.id))].sort();
+    const propertyIds = [...new Set(kinds.flatMap(kind => kind.properties.map(property => property.id)))].sort();
+    const relationIds = [...new Set(kinds.flatMap(kind => kind.relations.map(relation => relation.id)))].sort();
+    const world = input.world;
+    const scene = input.scene;
+    const actor = input.actor;
+    // Only the actor votes in their own act, and only on a decision open to them.
+    const voteIds = (actor?.votes ?? []).map(vote => vote.id).sort();
+    const requests = input.requests ?? [];
+    // The selected present IDs and cards share one response vocabulary.
+    const present = input.possiblePerceiverIds ?? [];
+    const localPeople = new Set([...scene.people.map(person => person.id), ...present, ...(actor ? [actor.id] : [])]);
+    const people = world.people;
+    const personIds = [...new Set([...people.map(person => person.id), ...present])].sort();
+    const placeIds = world.places.map(place => place.id).sort();
+    // Things at this place come from the scene; the directory adds what is nearby or held.
+    const objects = [...scene.objects.map(object => ({ id: object.id, placeId: scene.id, holderId: null })), ...world.objects];
+    const objectIds = [...new Set(objects.map(object => object.id))].sort();
+    const localObjectIds = [...new Set(objects.filter(object => object.placeId === scene.id
+            || (object.holderId !== null && localPeople.has(object.holderId))).map(object => object.id))].sort();
+    // A written thing or token that is here changes hands the way an object does.
+    const carriable = scene.entities.flatMap(entity => entity.holderId === undefined ? []
+        : [{ id: entity.id, placeId: entity.holderId === null ? scene.id : null, holderId: entity.holderId }]);
+    const reachable = [...objects, ...carriable];
+    const takeIds = [...new Set([...localObjectIds, ...carriable.map(thing => thing.id)])].sort();
+    const heldObjectIds = [...world.objects, ...carriable].filter(object => object.holderId !== null && localPeople.has(object.holderId))
+        .map(object => object.id).sort();
+    const tensionIds = world.tensions.map(tension => tension.id).sort();
+    const visibleTensionIds = world.tensions.filter(tension => tension.participants.some(person => localPeople.has(person.id)))
+        .map(tension => tension.id).sort();
+    const perceiverIds = input.possiblePerceiverIds.slice().sort();
+    const reactorIds = input.presentCharacterIds.slice().sort();
+    const knownIds = [...new Set([...personIds, ...placeIds])].sort();
+    const typedValue = (type) => type === 'flag' ? { type: 'boolean' } : type === 'number' ? { type: 'number' }
+        : type === 'time' ? { type: 'integer', minimum: 0 } : type === 'level' ? { type: 'string', enum: ['none', 'low', 'medium', 'high'] }
+            : type === 'id' ? { type: 'string', enum: knownIds } : str(2000);
+    const idField = (ids, field, optional = false) => described(optional ? nullable({ type: 'string', enum: ids }) : { type: 'string', enum: ids }, effectFields[field].description);
+    // A ruling names the kind of act when a norm or a gate in scope speaks about that kind.
+    const actionKinds = [...new Set(kinds.flatMap(kind => kind.mechanics.flatMap(mechanic => mechanic.kind === 'norm' && mechanic.actionKind !== undefined ? [mechanic.actionKind]
+            : mechanic.kind === 'gate' ? (mechanic.blockedActionKinds ?? []).filter(actionKind => !ENGINE_ACTION_KINDS.has(actionKind)) : [])))].sort();
+    const arms = flatEffectArms
+        .filter(arm => (objectIds.length > 0 || carriable.length > 0 || arm.properties.kind.const !== 'object.update')
+        && (takeIds.length > 0 || arm.properties.kind.const !== 'take')
+        && (heldObjectIds.length > 0 || arm.properties.kind.const !== 'drop')
+        && (scene.entities.length > 0 || !['property.set', 'relation.set'].includes(arm.properties.kind.const))
+        && (tensionIds.length > 0 || arm.properties.kind.const !== 'tension.update')
+        && (actor !== undefined && localPeople.size > 1 || arm.properties.kind.const !== 'request.open')
+        && (voteIds.length > 0 || arm.properties.kind.const !== 'ballot')
+        // A happening removes no one from the story; people leave by their own decisions.
+        && (input.phase !== 'world' || arm.properties.kind.const !== 'person.leave'))
+        .flatMap(arm => {
+        const kind = arm.properties.kind.const;
+        // Options for moving and taking grow with places and holders, not with people and things:
+        // everyone at one place shares its neighbors, and everything one holder has shares its takers.
+        if (kind === 'move') {
+            // A happening moves no one: people walk by their own decisions. The player moves only by their own act.
+            if (input.phase === 'world')
+                return [];
+            const listed = new Set(world.people.map(person => person.id));
+            const movers = [...world.people.filter(person => !person.isPlayer || person.id === actor?.id),
+                ...reactorIds.filter(id => !listed.has(id)).map(id => ({ id, placeId: scene.id }))];
+            const origins = [...new Set(movers.map(person => person.placeId))].sort();
+            return origins.flatMap(origin => {
+                const destinations = [...new Set(world.places.find(place => place.id === origin)?.connections ?? [])].filter(id => id !== origin).sort();
+                const walkers = movers.filter(person => person.placeId === origin).map(person => person.id).sort();
+                if (walkers.length === 0)
+                    return [];
+                return destinations.length > 0 ? [{ ...arm, properties: { ...arm.properties,
+                            personId: described({ type: 'string', enum: walkers }, effectFields.personId.description),
+                            placeId: described({ type: 'string', enum: destinations }, 'Neighboring place the person goes to.'), } }] : [];
+            });
+        }
+        if (kind === 'take') {
+            const holders = [...new Set(takeIds.map(id => reachable.find(object => object.id === id).holderId))];
+            return holders.flatMap(holder => {
+                const things = takeIds.filter(id => reachable.find(object => object.id === id).holderId === holder);
+                const takers = [...localPeople].filter(id => id !== holder).sort();
+                return takers.length > 0 ? [{ ...arm, properties: { ...arm.properties,
+                            objectId: described(things.length === 1 ? { const: things[0] } : { type: 'string', enum: things }, effectFields.objectId.description),
+                            personId: described({ type: 'string', enum: takers }, effectFields.personId.description),
+                        } }] : [];
+            });
+        }
+        const fields = {};
+        if (kind === 'entity.create')
+            return kinds.map(definition => ({ ...arm,
+                required: arm.required,
+                properties: { ...arm.properties,
+                    // A fire, a flood or a sound stays where it is, and an injury or a debt belongs to no hand.
+                    ...(neverHeld(LIVING_ENGINE_VERSION, definition.id, definition) ? { personId: described({ type: 'null' }, 'No one holds this kind of thing.') } : {}),
+                    kindId: described({ const: definition.id }, effectFields.kindId.description),
+                    placeId: described({ enum: [scene.id, null] }, 'Place where the new thing is; null when it belongs to no place, such as an agreement, a debt, a right, or a rumor.'),
+                    initialProperties: described({ type: 'object', additionalProperties: false,
+                        required: definition.properties.filter(property => property.requiredOnCreate).map(property => property.id),
+                        properties: Object.fromEntries(definition.properties.map(property => [property.id,
+                            property.type === 'flag' ? { type: 'boolean' }
+                                : property.type === 'number' ? { type: 'number' }
+                                    : property.type === 'time' ? { type: 'integer', minimum: 0, description: 'Minutes since Day 1, 00:00; now is clockMinutes.' }
+                                        : property.type === 'level' ? { type: 'string', enum: ['none', 'low', 'medium', 'high'] }
+                                            : property.type === 'id' ? { type: 'string', maxLength: 64, description: 'Id of a person, place or thing in the input.' }
+                                                : str(2000)])) }, 'Values written when this entity is created. Include every required property.'), },
+            }));
+        // One option for each kind here: its things, its properties, and values of its properties' types
+        // only, with an id naming a person or a place.
+        const addsLine = input.textWrites === 'add';
+        if (kind === 'property.set')
+            return kinds.flatMap(definition => {
+                const entityIds = scene.entities.filter(entity => entity.kindId === definition.id).map(entity => entity.id).sort();
+                const types = [...new Set(definition.properties.map(property => property.type))].sort();
+                if (entityIds.length === 0 || types.length === 0)
+                    return [];
+                return [{ ...arm, properties: { ...arm.properties,
+                            ...(addsLine ? { kind: { const: kind, description: ADDED_LINE_MEANING } } : {}),
+                            entityId: described({ type: 'string', enum: entityIds }, effectFields.entityId.description),
+                            propertyId: described({ type: 'string', enum: definition.properties.map(property => property.id).sort() }, effectFields.propertyId.description),
+                            value: described({ anyOf: [...types.map(type => type === 'text' ? (addsLine ? described(str(MAX_ADDED_LINE), 'Only the words written now; what is written stays.')
+                                        : described(str(2000), 'The whole text as it now reads, with the change.')) : typedValue(type)), { type: 'null' }] }, effectFields.value.description) } }];
+            });
+        // Likewise one link option for each kind here that has links: its things and its own relations only.
+        if (kind === 'relation.set')
+            return kinds.flatMap(definition => {
+                const entityIds = scene.entities.filter(entity => entity.kindId === definition.id).map(entity => entity.id).sort();
+                if (entityIds.length === 0 || definition.relations.length === 0)
+                    return [];
+                return [{ ...arm, properties: { ...arm.properties,
+                            entityId: described({ type: 'string', enum: entityIds }, effectFields.entityId.description),
+                            relationId: described({ type: 'string', enum: definition.relations.map(relation => relation.id).sort() }, effectFields.relationId.description) } }];
+            });
+        if (kind === 'request.open') {
+            fields.personId = described({ const: actor.id }, 'Actor who makes the request.');
+            fields.targetId = described({ type: 'string', enum: [...localPeople].filter(id => id !== actor.id).sort() }, 'Person here who receives the request.');
+            fields.priorId = described(requests.length > 0
+                ? nullable({ type: 'string', enum: requests.map(request => request.id).sort() }) : { type: 'null' }, effectFields.priorId.description);
+        }
+        if (kind === 'ballot') {
+            fields.personId = described({ const: actor.id }, 'The actor, who casts their own vote.');
+            fields.entityId = described({ type: 'string', enum: voteIds }, 'Decision voted on.');
+            fields.choice = described({ type: 'string', enum: ['yes', 'no', 'abstain'] }, effectFields.choice.description);
+        }
+        if (kind === 'schedule')
+            fields.personId = described({ type: 'null' }, effectFields.personId.description);
+        if (fieldsByEffect[kind].includes('personId') && !['person.create', 'schedule', 'request.open', 'ballot'].includes(kind))
+            fields.personId = idField(personIds, 'personId', kind === 'object.update');
+        // A happening sends away only someone it brings in, heard on a call; the rest leave by their own decisions.
+        if (kind === 'person.away' && input.phase === 'world')
+            fields.personId = described(str(64), 'Someone this ruling brings in who is only on a call.');
+        if (['take', 'drop', 'object.update'].includes(kind))
+            fields.objectId = idField(kind === 'object.update' ? [...new Set([...objectIds, ...carriable.map(thing => thing.id)])].sort() : kind === 'drop' ? heldObjectIds : takeIds, 'objectId');
+        if (fieldsByEffect[kind].includes('placeId') && kind !== 'place.create')
+            fields.placeId = idField(placeIds, 'placeId', !['move', 'drop', 'person.create'].includes(kind));
+        if (kind === 'tension.update')
+            fields.tensionId = idField(tensionIds, 'tensionId');
+        if (['relationship', 'commitment', 'message'].includes(kind))
+            fields.targetId = idField(personIds, 'targetId');
+        if (['hold', 'object.update'].includes(kind))
+            fields.targetId = idField(personIds, 'targetId', true);
+        if (kind === 'message')
+            fields.sourcePersonId = idField(personIds, 'sourcePersonId', true);
+        if (kind === 'tension.create')
+            fields.participantIds = described({ type: 'array', items: { type: 'string', enum: personIds }, maxItems: 6 }, effectFields.participantIds.description);
+        return [{ ...arm, properties: { ...arm.properties, ...fields } }];
+    });
+    return { ...attemptResponseSchema, properties: { ...attemptResponseSchema.properties,
+            actionKind: described(actionKinds.length > 0 ? nullable({ type: 'string', enum: actionKinds }) : { type: 'null' }, attemptResponseSchema.properties.actionKind.description),
+            stateUpdates: described({ type: 'array', items: { anyOf: arms.map(kindFirst('values')) }, maxItems: 8 }, attemptResponseSchema.properties.stateUpdates.description),
+            perceivedBy: described({ type: 'array', items: perceiverIds.length > 0 ? { type: 'string', enum: perceiverIds } : str(64), maxItems: Math.min(32, perceiverIds.length) }, attemptResponseSchema.properties.perceivedBy.description),
+            reactorIds: described({ type: 'array', items: reactorIds.length > 0 ? { type: 'string', enum: reactorIds } : str(64), maxItems: Math.min(2, reactorIds.length) }, attemptResponseSchema.properties.reactorIds.description),
+            visibleObjectIds: described({ type: 'array', items: localObjectIds.length > 0 ? { type: 'string', enum: localObjectIds } : str(64), maxItems: Math.min(48, localObjectIds.length) }, attemptResponseSchema.properties.visibleObjectIds.description),
+            visibleTensionIds: described({ type: 'array', items: visibleTensionIds.length > 0 ? { type: 'string', enum: visibleTensionIds } : str(64), maxItems: Math.min(32, visibleTensionIds.length) }, attemptResponseSchema.properties.visibleTensionIds.description),
+            settledTensionId: described(tensionIds.length > 0 ? nullable({ type: 'string', enum: tensionIds }) : { type: 'null' }, attemptResponseSchema.properties.settledTensionId.description),
+        } };
+}
+// An activity: its private purpose, what anyone watching sees, where and with whom, and how long it lasts.
+// Round 9: named "doing", the outward view drew the person's aim in 9 of 60 answers; "seenDoing" drew none.
+const ACTIVITY = { type: 'object', additionalProperties: false, required: ['intent', 'seenDoing', 'placeId', 'targetId', 'inMinutes'], properties: {
+        intent: described(str(300), 'Your private purpose.'), seenDoing: described({ ...str(200), minLength: 3 }, 'What anyone watching sees you doing.'),
+        placeId: nullable(str(64)), targetId: nullable(str(64)), inMinutes: described({ type: 'integer', minimum: 1, maximum: 100_000 }, 'Minutes it really takes, often 30 to 120. Replies and anything you notice reach you during it.')
+    } };
+export const reactionResponseSchema = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['say', 'act', 'toIds', 'mood', 'weight', 'leaveToPlaceId', 'trust', 'warmth', 'relationshipNote', 'belief', 'commitment', 'newGoal', 'goalDone', 'plan', 'tell', 'suggestedReplies', 'endConversation', 'request', 'requestDecision', 'answered', 'stance'],
+    properties: {
+        say: described(nullable(str(MAX_SPOKEN)), 'Your words to people here; null for silence.'),
+        request: described(nullable({ type: 'object', additionalProperties: false,
+            required: ['topic', 'receiverId', 'priorId'],
+            properties: { topic: str(600), receiverId: str(64), priorId: nullable(str(64)) } }), 'A concrete ask of someone in this line, with priorId when it repeats a known request; else null.'),
+        requestDecision: described(nullable({ type: 'object', additionalProperties: false, required: ['id', 'status'],
+            properties: { id: str(64), status: { type: 'string', enum: ['answered', 'refused', 'done'] } } }), 'Your answer to an open request to you; else null.'),
+        answered: described(nullable(str(64)), 'Id of your own open request these words answer; else null.'),
+        act: described(nullable(str(200)), 'One physical act you try now; null if you only speak.'),
+        toIds: described(ids(4), 'People here you address.'),
+        mood: described(str(40), 'Your feeling now in a few words.'),
+        weight: described({ type: 'integer', minimum: 1, maximum: 10 }, 'How serious this is to you, 1 to 10.'),
+        stance: described(nullable({ type: 'string', enum: ['undecided', 'cooperate', 'refuse', 'report', 'avoid', 'confront'] }), 'Your decision toward the actor after a serious act; else null.'),
+        leaveToPlaceId: described(nullable(str(64)), 'Exit you take now; else null.'),
+        trust: described({ type: 'integer', minimum: -20, maximum: 20 }, 'Change in your trust of the actor.'),
+        warmth: described({ type: 'integer', minimum: -20, maximum: 20 }, 'Change in your warmth toward the actor.'),
+        relationshipNote: described(nullable(str(200)), 'Why your feelings changed; else null.'),
+        belief: described(nullable({ type: 'object', additionalProperties: false, required: ['subject', 'claim'], properties: { subject: str(120), claim: str(300) } }), 'A conclusion you now hold; else null.'),
+        commitment: described(nullable({ type: 'object', additionalProperties: false, required: ['toId', 'text', 'dueInMinutes', 'placeId'], properties: { toId: str(64), text: str(300), dueInMinutes: nullable({ type: 'integer', minimum: 0, maximum: 100_000 }),
+                placeId: described(nullable(str(64)), 'Where you promised to be, when you promised to be somewhere; else null.') } }), 'A promise you make; else null.'),
+        newGoal: described(nullable(str(300)), 'A new aim; else null.'),
+        goalDone: described(nullable(str(300)), 'Id of your goal now resolved; else null.'),
+        plan: described(nullable(ACTIVITY), 'A new activity you switch to now; null to carry on.'),
+        tell: described(nullable({ type: 'object', additionalProperties: false, required: ['targetId', 'text'], properties: { targetId: str(64), text: str(300) } }), 'Someone to inform and what to tell them; else null.'),
+        suggestedReplies: described({ type: 'array', items: str(120), maxItems: 3 }, 'Lines the player might say next, in the player\'s voice.'),
+        endConversation: described({ type: 'boolean' }, 'Whether you end this exchange.'),
+    },
+};
+// The engine's own action kinds, which gates block outside any ruling.
+export const ENGINE_ACTION_KINDS = new Set(['move', 'speak', 'message', 'act', 'incapacitate']);
+export function scopedReactionResponseSchema(input) {
+    const identity = input.identity;
+    const blocked = new Set(identity.blocked ?? []);
+    const requests = input.requests;
+    const openIds = requests.filter(request => request.toId === identity.id && request.status === 'open').map(request => request.id).sort();
+    // Only the person spoken to can answer what this person asked them.
+    const speakerId = input.happened?.byId ?? null;
+    const askedIds = requests.filter(request => request.fromId === identity.id && request.toId === speakerId && request.status === 'open')
+        .map(request => request.id).sort();
+    const goalIds = [...new Set((input.goals ?? []).map(goal => goal.id))].sort();
+    // People here may be addressed, except someone who has left this person's last lines unanswered.
+    const addressable = directoryPeople(input).filter(person => person.here === true && person.id !== identity.id && person.noAnswerSince === undefined)
+        .map(person => person.id).sort();
+    return withBallot({ ...reactionResponseSchema, properties: { ...reactionResponseSchema.properties,
+            requestDecision: described(openIds.length > 0 ? nullable({ type: 'object', additionalProperties: false,
+                required: ['id', 'status'], properties: { id: { type: 'string', enum: openIds },
+                    status: { type: 'string', enum: ['answered', 'refused', 'done'] } } }) : { type: 'null' }, reactionResponseSchema.properties.requestDecision.description),
+            answered: described(askedIds.length > 0 ? nullable({ type: 'string', enum: askedIds }) : { type: 'null' }, reactionResponseSchema.properties.answered.description),
+            goalDone: described(goalIds.length > 0 ? nullable({ type: 'string', enum: goalIds }) : { type: 'null' }, reactionResponseSchema.properties.goalDone.description),
+            toIds: described(addressable.length > 0 ? { type: 'array', items: { type: 'string', enum: addressable }, maxItems: Math.min(4, addressable.length) } : { type: 'array', maxItems: 0 }, reactionResponseSchema.properties.toIds.description),
+            // A gated person is offered no line or act of the blocked kinds.
+            ...(blocked.has('speak') ? { say: described({ type: 'null' }, reactionResponseSchema.properties.say.description) } : {}),
+            ...(blocked.has('act') ? { act: described({ type: 'null' }, reactionResponseSchema.properties.act.description) } : {}),
+        } }, input);
+}
+// Someone with a vote open to them may cast it in this answer; anyone else is offered no ballot at all.
+// On their own turn to vote they must cast it; abstaining is a choice.
+function withBallot(schema, input, turn = false) {
+    const voteIds = (input.votes ?? []).map(vote => vote.id).sort();
+    if (voteIds.length === 0)
+        return schema;
+    const cast = { type: 'object', additionalProperties: false, required: ['decisionId', 'choice'], properties: {
+            decisionId: { type: 'string', enum: voteIds }, choice: { type: 'string', enum: ['yes', 'no', 'abstain'] }
+        } };
+    return { ...schema, required: [...schema.required, 'ballot'], properties: { ...schema.properties,
+            ballot: turn ? described(cast, 'Your own vote on the open decision, cast now.') : described(nullable(cast), 'Your own vote on an open decision, cast now; else null.') } };
+}
+const PLAN_ACTION_GATES = { go: 'move', 'go-home': 'move', speak: 'speak', message: 'message', attempt: 'act' };
+const directoryPeople = (input) => (input.directory?.people ?? []);
+export function scopedPlanResponseSchema(input) {
+    const identity = input.identity;
+    const blocked = new Set(identity.blocked ?? []);
+    const actions = PLAN_ACTIONS.filter(action => !blocked.has(PLAN_ACTION_GATES[action] ?? ''));
+    // Anyone known may be sought out, except someone who has left this person's last lines unanswered.
+    const targets = directoryPeople(input).filter(person => person.id !== identity.id && person.noAnswerSince === undefined).map(person => person.id).sort();
+    return withBallot({ ...planResponseSchema, properties: { ...planResponseSchema.properties,
+            action: described({ type: 'string', enum: actions }, planResponseSchema.properties.action.description),
+            targetId: described(targets.length > 0 ? nullable({ type: 'string', enum: targets }) : { type: 'null' }, planResponseSchema.properties.targetId.description) } }, input, true);
+}
+export const speechImpactResponseSchema = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['importance', 'pressure', 'loud', 'addressedIds', 'aboutIds'],
+    properties: {
+        importance: described({ type: 'integer', minimum: 1, maximum: 10 }, 'Social impact, 1 routine to 10 severe.'),
+        pressure: described(nullable({ type: 'object', additionalProperties: false, required: ['kind', 'text', 'dueInMinutes'], properties: {
+                kind: { type: 'string', enum: ['demand', 'threat', 'accusation', 'proposal', 'promise'] },
+                text: described(str(200), 'What is demanded, threatened, charged, proposed or promised.'),
+                dueInMinutes: described(nullable({ type: 'integer', minimum: 0, maximum: 100_000 }), 'When a promise falls due, in minutes from now; else null.')
+            } }), 'What the line presses on listeners; else null.'),
+        loud: described({ type: 'boolean' }, 'True only if shouted, loud enough to carry next door.'),
+        addressedIds: described({ type: 'array', items: str(64), maxItems: 4 }, 'People these words are for; empty for the room.'),
+        aboutIds: described({ type: 'array', items: str(64), maxItems: 4 }, 'Things here the words are about.'),
+    },
+};
+// A line may be for someone present or someone known elsewhere.
+export function scopedSpeechImpactResponseSchema(presentIds, thingIds = []) {
+    return { ...speechImpactResponseSchema, properties: { ...speechImpactResponseSchema.properties,
+            addressedIds: described({ type: 'array', items: presentIds.length > 0 ? { type: 'string', enum: [...presentIds].sort() } : str(64), maxItems: Math.min(4, presentIds.length) }, speechImpactResponseSchema.properties.addressedIds.description),
+            aboutIds: described({ type: 'array', items: thingIds.length > 0 ? { type: 'string', enum: [...thingIds].sort() } : str(64), maxItems: Math.min(4, thingIds.length) }, speechImpactResponseSchema.properties.aboutIds.description) } };
+}
+const PLAN_ACTIONS = ['go', 'speak', 'message', 'attempt', 'go-home', 'wait'];
+export const planResponseSchema = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['action', 'placeId', 'targetId', 'text', 'mood', 'nextPlan', 'request', 'stance'],
+    properties: {
+        action: described({ type: 'string', enum: [...PLAN_ACTIONS] }, 'One act now; go-home: away until nextPlan ends.'),
+        placeId: described(nullable(str(64)), 'Destination for go; else null.'),
+        targetId: described(nullable(str(64)), 'Person for speak or message; else null.'),
+        text: described(nullable(str(MAX_SPOKEN)), 'Words to say or act to try; else null.'),
+        request: described(nullable({ type: 'object', additionalProperties: false, required: ['topic', 'priorId'],
+            properties: { topic: str(600), priorId: nullable(str(64)) } }), 'When your words ask someone to act: its topic, with priorId for a known request.'),
+        mood: described(str(40), 'Your feeling now in a few words.'),
+        nextPlan: described(ACTIVITY, 'What you do next, until it ends.'),
+        stance: described(nullable({ type: 'string', enum: ['undecided', 'cooperate', 'refuse', 'report', 'avoid', 'confront'] }), 'Where you now stand toward someone after their serious act; else null.'),
+    },
+};
+export const messageReplyResponseSchema = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['reply', 'mood', 'trust', 'warmth', 'belief', 'plan'],
+    properties: {
+        reply: described(nullable(str(MAX_SPOKEN)), 'Your reply; null for silence.'),
+        mood: described(str(40), 'Your feeling now in a few words.'),
+        trust: described({ type: 'integer', minimum: -20, maximum: 20 }, 'Change in trust of the sender.'),
+        warmth: described({ type: 'integer', minimum: -20, maximum: 20 }, 'Change in warmth toward the sender.'),
+        belief: described(nullable({ type: 'object', additionalProperties: false, required: ['subject', 'claim'], properties: { subject: str(120), claim: str(300) } }), 'A conclusion you now hold; else null.'),
+        plan: described(nullable(ACTIVITY), 'A new activity you switch to; null to carry on.'),
+    },
+};
+export const epilogueResponseSchema = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['title', 'verdict', 'highlights', 'cast', 'closing'],
+    properties: {
+        title: described(str(120), 'Short title for the ending.'),
+        verdict: described(str(300), 'One sentence on the outcome.'),
+        highlights: described({ type: 'array', minItems: 1, maxItems: 5, items: str(240) }, 'Recorded major events in order.'),
+        cast: described({ type: 'array', maxItems: 4, items: { type: 'object', additionalProperties: false, required: ['name', 'line'], properties: { name: str(120), line: str(200) } } }, 'Where up to four recorded people ended up.'),
+        closing: described(str(200), 'One final line grounded in the recorded outcome.'),
+    },
+};