classes.ts

import clone from "just-clone";
import { describeTag, parseTags, TagType, unfoldTags } from "../parsetags";
import { TemplateFalse, TemplateTrue, tmpl } from "../template";
import {
  ChatType,
  EntityId,
  isPerson,
  isPromptRequest,
  isRoom,
  isStoryActionAttempt,
  isStoryDescription,
  isStoryDialog,
  MessageType,
  PersonScheduledEventType,
  PersonScheduleTemplateType,
  ScheduleId,
  StoryActionType,
  StoryEventType,
  StoryEventWithPositionsType,
  type ActionRequestType,
  type ChangesType,
  type ChangeType,
} from "../types";
import { historyForEntity as computeHistoryForEntity } from "./history";
import { coerceBoolean, coerceNumber, fixupText } from "./coerce";
import type { Model } from "./model";
import { mysteryTriggers } from "./mysteries";
import { pathTo } from "./pathto";
import { pronounsForGender } from "./pronouns";
import {
  intraActivityForTime,
  scheduleForTime,
  timeAsString,
} from "./scheduler";
import type { World } from "./world";
import { entitiesById, fieldsOf } from "./dynamic";
import { applyTag, type TagContext } from "./tags";
import { todoPrompt } from "./todos";
import { TagStreamParser } from "./tagstream";

export interface EntityInitType {
  id: EntityId;
  name?: string;
  shortDescription?: string;
  description?: string;
  inside?: EntityId;
  color?: string;
  invisible?: boolean;
}

export interface ParametersType {
  trigger?: string;
  /**
   * Set on a Person's reaction to a player event, and how much claim they
   * have on one of the turn's limited response slots; see lib/game/crowd.ts.
   * 3 = in the conversation (spoken to directly, or the player's current
   * interlocutor) and guaranteed a turn, never capped. 2 = named in a
   * description or action, 1 = overheard undirected speech, 0 = merely
   * attentive; these compete for the remaining slots. Absent on scripted
   * requests (triggers, ceremonies, wakeups), which are never capped.
   */
  reactionPriority?: number;
}

export abstract class Entity<ParametersT extends ParametersType = object> {
  name: string = "";
  shortDescription: string = "";
  description: string = "";
  color: string = "text-white";
  inside: EntityId | null = null;
  invisible: boolean = false;
  abstract type: string;
  public readonly id: EntityId;
  world!: World;

  constructor({
    id,
    name,
    shortDescription,
    description,
    color,
    inside,
    invisible,
  }: EntityInitType) {
    this.id = id;
    if (name) {
      this.name = name;
    }
    if (shortDescription) {
      this.shortDescription = shortDescription;
    }
    if (description) {
      this.description = description;
    }
    if (color) {
      this.color = color;
    }
    if (inside) {
      this.inside = inside;
    }
    if (invisible !== undefined) {
      this.invisible = invisible;
    }
  }

  clone(): this {
    const newInstance = new (
      this.constructor as new ({ id }: { id: string }) => this
    )({
      id: this.id,
    });
    Object.assign(newInstance, this);
    return newInstance as this;
  }

  myRoom(): Room {
    if (isRoom(this)) {
      return this as Room;
    }
    const room = this.world.entityRoom(this.id);
    if (!room) {
      return this.world.getRoom("Void")!;
    }
    return room;
  }

  applyChange(changes: ChangeType) {
    for (const [key, value] of Object.entries(changes.after)) {
      if (
        key === "inside" &&
        !entitiesById(this.world.entities)[value as EntityId]
      ) {
        console.warn(
          `Updating ${this.id}.${key} be inside ${value} but entity does not exist`,
        );
        continue;
      }
      if (key === "exits") {
        if (!isRoom(this)) {
          throw new Error("Tried to update exits on a non-room");
        }
        const existing = (this as unknown as Room).exits;
        let newExits = [...existing];
        if (!Array.isArray(value)) {
          throw new Error("Exits must be an array");
        }
        for (const exit of value) {
          const existingExit = existing.find((x) => x.roomId === exit.roomId);
          if (exit.deleted) {
            if (!existingExit) {
              console.warn("Tried to delete exit that does not exist", exit);
              continue;
            }
            newExits = newExits.filter((x) => x.roomId !== exit.roomId);
          } else {
            if (existingExit) {
              newExits = newExits.map((x) =>
                x.roomId === exit.roomId ? exit : x,
              );
            } else {
              newExits.push(exit);
            }
          }
          fieldsOf(this).exits = newExits;
        }
        continue;
      }
      if (key === "attitudes") {
        if (!isPerson(this)) {
          throw new Error("Tried to update attitudes on a non-person");
        }
        // Copy-on-write: clone() copies the record by reference, so mutating
        // it in place would write folded state into the pristine `original`
        // entities that undo and reload re-fold from.
        const merged = {
          ...(fieldsOf(this).attitudes as Record<string, unknown>),
        };
        for (const [id, attitude] of Object.entries(value)) {
          if (attitude === null) {
            delete merged[id];
          } else {
            merged[id] = attitude;
          }
        }
        fieldsOf(this).attitudes = merged;
        continue;
      }
      if (fieldsOf(this)[key] === undefined) {
        console.warn(
          `Updating ${this.id}.${key} to ${value} but attribute does not exist`,
        );
      }
      fieldsOf(this)[key] = value;
    }
  }

  onStoryEvent(
    storyEvent: StoryEventType,
  ): ActionRequestType<ParametersT>[] | void {
    return undefined;
  }

  makePromptRequest(parameters: ParametersT): ActionRequestType<ParametersT> {
    return {
      type: "promptRequest",
      id: this.id,
      parameters,
    };
  }

  async processTag({
    tag,
    model,
    parameters,
    storyEvent,
    llmResponse,
  }: {
    tag: TagType;
    model: Model;
    parameters: ParametersT;
    storyEvent: StoryEventType;
    llmResponse: string;
  }): Promise<StoryEventType> {
    // Name the tag rather than the object. The warning is what the evals count
    // as a protocol failure, and `console.warn("...", tag)` stringified to
    // "Got unexpected tag: [object Object]" — so the one record of what a model
    // actually emitted said nothing, at exactly the moment it was being used to
    // judge whether that model can run the game.
    console.warn(`Got unexpected tag: ${describeTag(tag)}`);
    return storyEvent;
  }

  afterPrompt(storyEvent: StoryEventType): StoryEventType {
    return storyEvent;
  }

  assemblePrompt(parameters: ParametersT): ChatType {
    throw new Error("Method not implemented.");
  }

  additionalPromptInstructions(parameters: ParametersT): string {
    return "";
  }

  /**
   * System-prompt content that is fixed for this character.
   *
   * Prompt caching matches a prefix, so the assembled prompt is ordered
   * stable-first: anything that changes between turns belongs in
   * volatileSystemInstructions instead, or the cache misses every turn.
   */
  additionalSystemInstructions(parameters: ParametersT): string {
    return "";
  }

  /** System-prompt content that changes as the game runs; goes after the fixed part. */
  volatileSystemInstructions(parameters: ParametersT): string {
    return "";
  }

  /** This entity's recent history, as chat messages for a prompt. */
  historyForEntity({ limit }: { limit?: number } = {}): MessageType[] {
    return computeHistoryForEntity(this, { limit });
  }

  currentLocationPrompt(parameters: ParametersT): string {
    const room = this.world.entityRoom(this.id);
    if (!room) {
      return "Located in an indeterminate location.";
    }
    return tmpl`
    ${room.name} (id: ${JSON.stringify(room.id)}) "${room.shortDescription}"
    `;
  }

  currentPeoplePrompt(parameters: ParametersT): string {
    const room = this.world.entityRoom(this.id);
    if (!room) {
      return "There are no people here.";
    }
    const entities = this.world
      .entitiesInRoom(room)
      .filter((x) => isPerson(x))
      .filter((x) => !x.invisible && x.id !== this.id);
    const lines = [];
    for (const entity of entities) {
      lines.push(`${entity.name} (${entity.pronouns}) {`);
      if (entity.id !== entity.name) {
        lines.push(`  id = ${JSON.stringify(entity.id)}`);
      }
      lines.push(
        `  ${entity.promptPersonDescription({ includeName: false, join: "\n  ", fullDescription: true })}`,
      );
      lines.push("}");
    }
    if (this.id !== "Ama") {
      lines.push(`Ama is always present {`);
      lines.push(`  ${this.world.entities.Ama.shortDescription}`);
      lines.push("}");
    }
    return lines.join("\n");
  }

  exitsPrompt(parameters: ParametersT): string {
    const room = this.world.entityRoom(this.id);
    if (!room || !room.exits?.length) {
      return "There are no exits.";
    }
    const lines = [];
    for (const exit of room.exits) {
      const target = this.world.getRoom(exit.roomId);
      if (!target) {
        console.warn("Exit target is not a room", exit.roomId);
        continue;
      }
      lines.push(
        tmpl`
        Exit locationId "${exit.roomId}" {
          name: ${target.name}
          "${target.shortDescription}"
        `,
      );
      if (exit.aliases) {
        lines.push(`  aliases: ${exit.aliases.join(", ")}`);
      }
      if (exit.restriction) {
        lines.push(`  exit is restricted by: "${exit.restriction}"`);
      }
      lines.push("}");
    }
    return lines.join("\n");
  }

  /**
   * Run the prompt, streaming narrative text to `model.streaming` if a
   * streaming backend is configured. Either way this resolves to the complete
   * response, so the caller's parse is identical — streaming only adds the
   * ability to show a turn while it is still arriving.
   */
  private async streamOrChat(model: Model, prompt: ChatType): Promise<string> {
    // Which character this prompt is for, for its usage record. Set here rather
    // than in each assemblePrompt because every entity prompt passes through.
    prompt.meta.entity ??= this.id;
    if (!model.chatStream) {
      return model.chat(prompt);
    }
    const parser = new TagStreamParser();
    const show = (events: ReturnType<TagStreamParser["feed"]>) => {
      for (const event of events) {
        if (event.kind === "close") {
          model.streaming.value = null;
        } else {
          model.streaming.value = { entityId: this.id, tag: event.tag };
        }
      }
    };
    try {
      const text = await model.chatStream(prompt, (delta) =>
        show(parser.feed(delta)),
      );
      show(parser.end());
      return text;
    } finally {
      // Never leave provisional text on screen, even if the request failed.
      model.streaming.value = null;
    }
  }

  /**
   * How many times to hand a broken response back and ask again.
   *
   * One. A model that misspells an attribute usually fixes it when told, and a
   * model that doesn't fix it on the second go isn't going to on the third —
   * meanwhile every retry is a whole prompt's worth of money and a second of
   * the player waiting. Bounded at one because the failure being repaired is
   * cosmetic to the player: the turn still happened, it just recorded less than
   * it meant to.
   */
  static readonly PROTOCOL_RETRIES = 1;

  async executePrompt(model: Model, parameters: ParametersT) {
    const prompt = this.assemblePrompt(parameters);
    const roomId = this.world.entityRoom(this.id)?.id || "Void";

    let resp = "";
    let result: StoryEventType | null = null;
    let complaints: string[] = [];
    for (
      let attempt = 0;
      attempt <= (this.constructor as typeof Entity).PROTOCOL_RETRIES;
      attempt++
    ) {
      // On a retry the model is shown its own answer and what was wrong with
      // it, which is the shape it can act on. Reassembling the prompt from
      // scratch and hoping for better would be a reroll, not a correction.
      const attemptPrompt =
        attempt === 0
          ? prompt
          : {
              ...prompt,
              messages: [
                ...prompt.messages,
                { role: "assistant" as const, content: resp },
                {
                  role: "user" as const,
                  content: `Some of that could not be applied:\n${complaints.join("\n")}\n\nReply again with the complete set of tags for this turn, fixing those. Use only attributes that already exist.`,
                },
              ],
            };
      resp = fixupText(
        await model.run(() => this.streamOrChat(model, attemptPrompt)),
      );
      complaints = [];
      result = await this.applyResponse({
        model,
        parameters,
        resp,
        roomId,
        title: prompt.meta.title,
        complaints,
      });
      if (!complaints.length) {
        break;
      }
    }

    result = this.afterPrompt(result!);
    await model.addStoryEvent(result);
  }

  /** Turn one response into a story event, collecting what wouldn't apply. */
  private async applyResponse({
    model,
    parameters,
    resp,
    roomId,
    title,
    complaints,
  }: {
    model: Model;
    parameters: ParametersT;
    resp: string;
    roomId: EntityId;
    title: string;
    complaints: string[];
  }): Promise<StoryEventType> {
    let tags = unfoldTags(parseTags(resp), {
      // We don't want to unfold this, because it's for planning, not action:
      ignoreContainers: ["context"],
      // These sometimes are produced without content, but then they are meaningless:
      trimEmpty: ["dialog", "description"],
    });
    if (tags.length === 1 && tags[0]!.type === "context") {
      // This happens sometimes when it puts *everything* in a context tag. We don't always want to look inside context but if there's only context then we do...
      tags = unfoldTags(parseTags(tags[0]!.content), {});
    }
    let result: StoryEventType = {
      id: this.id,
      totalTime: 0,
      changes: {},
      actions: [],
      roomId,
      llmTitle: title,
      llmResponse: resp,
      // Recorded for replay/undo; the concrete shape varies per entity type, so
      // it is stored as a plain record.
      llmParameters: parameters as Record<string, unknown>,
    };
    const tagContext: TagContext = {
      world: this.world,
      entityId: this.id,
      roomId,
      // FIXME: kind of a hack that should be done in a subclass:
      subject: (parameters as { examine?: string }).examine || undefined,
      complaints,
    };
    for (const tag of tags) {
      if (applyTag(tag, result, tagContext)) {
        continue;
      }
      // Not part of the base protocol - let the entity's own hook handle it.
      result = await this.processTag({
        tag,
        model,
        parameters,
        storyEvent: result,
        llmResponse: resp,
      });
    }
    return result;
  }

  changes(values: Partial<this>): Record<string, ChangeType> {
    const c: ChangeType = {
      before: {},
      after: {},
    };
    for (const [key, value] of Object.entries(values)) {
      c.before[key] = fieldsOf(this)[key];
      c.after[key] = value;
    }
    return {
      [this.id]: c,
    };
  }

  mergeChanges(event: StoryEventType, values: Partial<this>): StoryEventType {
    const changes = this.changes(values);
    const mine = changes[this.id]!;
    const existing = event.changes[this.id];
    if (existing) {
      for (const [key, value] of Object.entries(mine.after)) {
        existing.after[key] = value;
      }
    } else {
      event.changes[this.id] = mine;
    }
    return event;
  }

  /**
   * The character's current feelings about people, for their own prompt only.
   *
   * Empty string when there are none, which is the usual case — the [[...]]
   * template wrapper then drops the section entirely, so a character with no
   * particular feelings carries no text about feelings at all.
   */
  attitudesPrompt(): string {
    if (!isPerson(this)) {
      return "";
    }
    const entries = Object.entries(this.attitudes);
    if (!entries.length) {
      return "";
    }
    const lines = entries.map(([id, feeling]) => {
      const who = this.world.getEntity(id);
      return `- ${who?.name ?? id} (${id}): ${feeling}`;
    });
    return tmpl`
    ${this.name}'s current private feelings, which only ${this.name} knows and which color how ${this.name} behaves:
    ${lines.join("\n")}
    `;
  }

  myMysteryHints(): string {
    const results: string[] = [];
    for (const mystery of this.world.unveiledMysteries()) {
      let hints: Record<EntityId, string> = {};
      if (mystery.state === "revealed") {
        hints = mystery.revealedHints;
      } else if (mystery.state === "available") {
        hints = mystery.availableHints;
      } else if (mystery.state === "solved") {
        hints = mystery.solvedHints;
      }
      // Collected per mystery, so the "*" and meter lines attach to the
      // mystery they belong to. (This also fixes a leak: the old cross-mystery
      // `results.length` check could hand a room one mystery's "*" hint
      // because a *different* mystery had briefed that room.)
      const mine: string[] = [];
      const selfHint = hints[this.id];
      if (selfHint) {
        mine.push(selfHint);
      }
      const roomHint = hints[this.myRoom().id];
      if (this.myRoom().id !== this.id && roomHint) {
        mine.push(roomHint);
      }
      if ((mine.length || isPerson(this)) && hints["*"]) {
        mine.unshift(hints["*"]);
      }
      if (mine.length && mystery.meters.length) {
        mine.push(this.meterReadout(mystery.meters));
      }
      results.push(...mine);
    }
    return results.join("\n");
  }

  /**
   * The current values of a mystery's meters, as one line of prompt text.
   *
   * Hints are static strings, so an instruction like "her behavior is keyed to
   * PLAYER.civicPoints" had no way to see the number: a model only knew a
   * counter's value while its own `<set>` events were still inside the sliding
   * history window. The Archivist's angst registers shipped with that bug.
   * Any character a mystery briefs gets the mystery's declared meters appended
   * to the hint block.
   */
  meterReadout(meters: string[]): string {
    const parts = meters.map((meter) => {
      const [entityId, attr] = meter.split(".");
      const entity = entityId ? this.world.getEntity(entityId) : undefined;
      const value = entity && attr ? fieldsOf(entity)[attr] : undefined;
      return `${meter} = ${JSON.stringify(value)}`;
    });
    return `Current values: ${parts.join(", ")}`;
  }
}

export interface SoundTrackType {
  url: string;
  sunoUrl: string;
}

export class Room extends Entity {
  type = "room";
  exits: Exit[] = [];
  userInputInstructions = "";
  visits: number = 0;
  excludeFromMap = false;
  /**
   * Whether Ama will name this room or route to it for `/nav`.
   *
   * Bedrooms are off it: somewhere private is somewhere she does not send
   * people, and anyone in a room that is off it is not findable either. That is
   * the seam for anything later that should hide a person — being unfindable is
   * a property of where you are rather than a special case in the lookup.
   *
   * Separate from `excludeFromMap`, which is about drawing: a room can be
   * absent from the map and still be somewhere you can be directed to.
   */
  onNav = true;
  soundtrack?: SoundTrackType;
  actionPrompt = "";

  constructor({
    exits,
    userInputInstructions,
    visits,
    excludeFromMap,
    onNav,
    soundtrack,
    actionPrompt,
    promptForPerson,
    ...props
  }: EntityInitType & {
    exits?: Exit[];
    userInputInstructions?: string;
    visits?: number;
    excludeFromMap?: boolean;
    onNav?: boolean;
    soundtrack?: SoundTrackType;
    actionPrompt?: string;
    promptForPerson?: (this: Room, person: Person) => string;
  }) {
    super(props);
    if (exits) {
      this.exits = exits;
    }
    if (userInputInstructions !== undefined) {
      this.userInputInstructions = userInputInstructions;
    }
    if (visits !== undefined) {
      this.visits = visits;
    }
    if (excludeFromMap !== undefined) {
      this.excludeFromMap = excludeFromMap;
    }
    if (onNav !== undefined) {
      this.onNav = onNav;
    }
    if (soundtrack) {
      this.soundtrack = soundtrack;
    }
    if (actionPrompt) {
      this.actionPrompt = actionPrompt;
    }
    if (promptForPerson) {
      this.promptForPerson = promptForPerson.bind(this);
    }
  }

  override clone(): this {
    const newInstance = super.clone() as this;
    newInstance.exits = this.exits.map((exit) => ({ ...exit }));
    return newInstance as this;
  }

  promptForPerson(person: Person): string {
    return "";
  }
}

// The Archivist console room. Its distinctive terminal-style rendering lives in
// the view (app/renderstoryaction.tsx); this class only marks the room type.
export class ArchivistRoom extends Room {}

export interface Exit {
  name?: string;
  roomId: EntityId;
  aliases?: string[];
  /**
   * Prose conditions on passing, adjudicated by a model when the player tries
   * (`assembleMovePrompt`). Right for doors a character can decide to allow —
   * the quarters doors, which their owners walk through nightly.
   */
  restriction?: string;
  /**
   * A hard lock the engine enforces: `<goto>` is refused without asking a
   * model, `pathTo` will not route through it (so schedules and the cuff
   * don't), and the action adjudicator is told no attempt on it succeeds.
   * For doors that must hold against anything the player can type; only an
   * engine-made event (the Star Citizen ceremony) opens one. A `restriction`
   * alongside it is display text, explaining the door the model never gets
   * to adjudicate.
   */
  sealed?: boolean;
}

export type RelationshipRatingType = "positive" | "negative" | "neutral";

export interface RelationshipType {
  background?: string;
  polite?: RelationshipRatingType;
  fun?: RelationshipRatingType;
  respectable?: RelationshipRatingType;
  trustworthy?: RelationshipRatingType;
}

/**
 * One emotional meter, declared on the character it belongs to.
 *
 * The value is a plain numeric field on the person (so `<set>` increments,
 * complaints validation, `Mystery.meters` and `attrSet`/`reaches` triggers all
 * work on it unchanged); this spec is everything else — the range, what moves
 * it, and what each level means. The model only ever judges the moment ("did
 * this turn annoy him? +1"); the level is engine arithmetic and the register
 * text tells the model how to play the number it is at. Counted rather than
 * judged, for the same reason as Archivist.angst: "sufficiently annoyed" is a
 * threshold a model fires on turn one or never.
 *
 * Keep it to one, two, at most three meters per character, in small ranges:
 * the player has to be able to comprehend the dial from behavior alone.
 */
export interface StatSpecType {
  /** Initial value. Defaults to 0. */
  start?: number;
  /** Defaults to 0. Negative minimums are fine (a like/dislike axis). */
  min?: number;
  /** Defaults to 10, but declare it; small ranges read better. */
  max?: number;
  /** What raises it, one flat line, shown to the model as the +1 criteria. */
  up?: string;
  /** What lowers it, the -1 criteria. */
  down?: string;
  /**
   * What the number means, keyed by the value each register starts at: the
   * character plays the highest register at or below the current value.
   */
  levels?: Record<number, string>;
}

export class Person<
  ParametersT extends ParametersType = ParametersType,
> extends Entity<ParametersT> {
  type = "person";
  pronouns: string = "they/them";
  roleplayInstructions: string = "";
  declare inside: EntityId;
  /**
   * How this character currently feels about specific people, keyed by entity
   * id, written and updated by the character itself via `<attitude toward=...>`.
   * Sparse on purpose: no key means no particular feeling, and that absence is
   * the default state — there is no "neutral" entry. The fold merges these
   * per key (see applyChanges), so one feeling changing doesn't clobber the
   * rest, and a `null` in a change deletes a feeling that has faded.
   */
  attitudes: Record<EntityId, string> = {};
  /**
   * The character's declared emotional meters; see StatSpecType. The values
   * live as plain numeric fields on the instance, named by these keys.
   */
  statSpecs: Record<string, StatSpecType> = {};
  scheduleTemplate: PersonScheduleTemplateType[] = [];
  todaysSchedule: PersonScheduledEventType[] = [];
  runningScheduleId: ScheduleId | null = null;

  constructor({
    pronouns,
    roleplayInstructions,
    attitudes,
    stats,
    scheduleTemplate,
    ...props
  }: EntityInitType & {
    pronouns?: string;
    roleplayInstructions?: string;
    attitudes?: Record<EntityId, string>;
    stats?: Record<string, StatSpecType>;
    scheduleTemplate?: PersonScheduleTemplateType[];
  }) {
    super(props);
    if (stats) {
      for (const [name, spec] of Object.entries(stats)) {
        if (name in this) {
          throw new Error(
            `Stat "${name}" on ${this.id} collides with an existing field`,
          );
        }
        fieldsOf(this)[name] = spec.start ?? 0;
      }
      this.statSpecs = stats;
    }
    if (pronouns) {
      this.pronouns = pronouns;
    }
    if (roleplayInstructions) {
      this.roleplayInstructions = roleplayInstructions;
    }
    if (!fieldsOf(this).inside) {
      this.inside = "Void";
    }
    if (attitudes) {
      this.attitudes = attitudes;
    }
    if (scheduleTemplate) {
      this.scheduleTemplate = scheduleTemplate;
    }
  }

  /**
   * The character's declared meters, rendered for their own prompt only:
   * current value, range, the +1/-1 criteria, and the register text for each
   * level. Empty string for the (usual) character with no meters, so the
   * [[...]] wrapper drops the section and no prompt grows for them.
   */
  metersPrompt(): string {
    const entries = Object.entries(this.statSpecs);
    if (!entries.length) {
      return "";
    }
    const parts = entries.map(([name, spec]) => {
      const lines = [
        `${name} = ${fieldsOf(this)[name]} (range ${spec.min ?? 0} to ${spec.max ?? 10})`,
      ];
      if (spec.up) {
        lines.push(`Raise it (+1) when: ${spec.up}`);
      }
      if (spec.down) {
        lines.push(`Lower it (-1) when: ${spec.down}`);
      }
      const levels = Object.entries(spec.levels ?? {}).sort(
        (a, b) => Number(a[0]) - Number(b[0]),
      );
      if (levels.length) {
        lines.push(
          `What the number means; play the highest register at or below the current value:`,
        );
        for (const [at, means] of levels) {
          lines.push(`${at}: ${means}`);
        }
      }
      return lines.join("\n");
    });
    return tmpl`
    ${this.name}'s meters, private to ${this.name}. The number sets the register ${this.name} plays in:

    ${parts.join("\n\n")}

    When this turn genuinely moves a meter, adjust it one step:

    <set attr="${this.id}.${entries[0]![0]}">+1</set>

    Use -1 for a step down. At most one step per meter per turn; most turns move nothing. When a meter moves, show the shift in ${this.name}'s behavior in the same response, so the player can feel the change without seeing the number.
    `;
  }

  override assemblePrompt(parameters: ParametersT): ChatType {
    const lastTo = this.lastSpokeTo()?.id || "";
    let hasInteracted = false;
    for (let i = this.world.model.liveUpdates.value.length - 1; i >= 0; i--) {
      const update = this.world.model.liveUpdates.value[i]!;
      if (update.id === this.id) {
        for (const action of update.actions) {
          if (isStoryDialog(action) && action.toId === "PLAYER") {
            hasInteracted = true;
            break;
          }
        }
      }
    }
    const schedule = scheduleForTime(this, this.world.timestampMinutes);
    const willLeave = schedule && !schedule.inside.includes(this.inside);
    const promptForPerson = this.world
      .entityRoom(this.id)
      ?.promptForPerson(this);
    const mysteryHints = this.myMysteryHints();
    // The <taskList> block below is length-sensitive, in both directions, and
    // was tuned against the evals rather than guessed at. Cutting it to two
    // sentences stopped tasks being created at all (task-list 3/5); the first,
    // wordier version got tasks created but made both model tiers sloppier
    // elsewhere — movement dropped a hallucinated `<set>` on a scenario that
    // had been clean. Re-run `pnpm evals --scenario task-list --scenario
    // movement` after editing it.
    return {
      meta: {
        title: `prompt ${this.id}`,
      },
      messages: [
        {
          role: "system",
          content: tmpl`
          You are a computer running a text adventure game. You will respond with tags to represent game action.

          In this step you will be playing the part of a character named "${this.name}" (${this.pronouns}).

          The human plays the character PLAYER — that is an id, used as-is in tags (as in <set attr="PLAYER.name">). PLAYER is currently known as "${this.world.entities.PLAYER.name}" (${this.world.entities.PLAYER.pronouns}); that may change as ${this.name} learns who they are.

          <characterDescription>
          ${this.description}
          </characterDescription>

          <roleplayInstructions>
          In general, the goal for the game to be FUN and SURPRISING. Move the conversation forward, and don't be afraid to overreact! ENGAGE with PLAYER and pay attention to what PLAYER says.

          ${this.roleplayInstructions}
          </roleplayInstructions>

          <taskList>
          PLAYER keeps a list of what they have agreed to do, shown to them in their interface.

          When ${this.name} asks PLAYER to do something, or PLAYER agrees to do something, add the response:

          <todo>a short instruction, as PLAYER would write it to themselves</todo>

          When that thing is genuinely finished, repeat the same wording as <todoDone>...</todoDone>. Nothing else belongs on the list.
          </taskList>

          ${this.additionalSystemInstructions(parameters)}

          [Everything above is fixed for this character. Everything below changes as the game is played.]

          The time is ${timeAsString(this.world.timestampMinutes)}
          ${this.name} is currently in the room "${this.myRoom().name}": ${this.myRoom().shortDescription}

          [[${IF(!hasInteracted)}This is the first time ${this.name} has spoken to PLAYER. There aren't many new people in Intra, so this might be a big deal.]]

          [[${promptForPerson}]]

          ${this.intraActivityDescription()}

          ${this.activityDescription(parameters)}

          The other people in the room ${this.myRoom().name} are:
          ${this.currentPeoplePrompt(parameters)}

          [[${this.attitudesPrompt()}]]

          [[${this.metersPrompt()}]]

          [[This character has some knowledge of some mysteries; follow these additional instructions:
          """
          ${mysteryHints}
          """

          Inventing around a mystery: invented detail is welcome, and invented side paths are welcome, but a side path must lead toward something real that the instructions above mention — a person, a place, a record. Do not invent evidence that names a culprit, answers a mystery's question, or points suspicion at anyone these instructions do not implicate. An invented lead the player follows should connect them back to the real trail.]]

          [[${todoPrompt(this.world.todos)}]]

          ${this.volatileSystemInstructions(parameters)}
          `,
        },
        ...this.historyForEntity({ limit: 10 }),
        {
          role: "user",
          content: tmpl`
          Given the above play state, respond as the character "${this.name}"

          [[This character has been triggered to act specifically by: "${parameters.trigger}"]]

          Begin by assembling the essential context given the above history, writing 4-5 words for each item:

          <context>
          1. Are there any special questions for this character that need to be answered? If so answer them here.
          2. Are there any facts that have to be constructed to continue the scene or response? If so then invent those facts and record them.
          3. ${this.name}'s goals, including listing out any specific goals previously noted in the prompt
          4. Relevant facts from the history
          5. How can this response be fun or surprising?
          6. ${this.name}'s reaction to any recent speech or events
          7. ${this.name}'s intention in this response
          8. Did this turn change how ${this.name} feels about a specific person? Name the person and the change, or write "no"
          </context>

          <responseFormat>
          Begin your response with <context>...</context>

          To generate speech add this response:

          <dialog character="${this.name}">1-3 sentences of dialog written as ${this.name}</dialog>

          To speak directly TO someone:

          <dialog character="${this.name}" to="${lastTo || "Jim"}">Dialog written as ${this.name} to ${lastTo || "Jim"}</dialog>
          [[${this.name} last spoke directly to ${lastTo}, so it's very likely ${this.heshe} is still speaking to them.]]

          If the character ${this.name} is performing an action, add this response (optionally with a rough estimate of the time it will take in minutes):

          <description minutes="5">Describe the action</description>

          You may record ${this.name}'s private state of mind:

          <mind>About one sentence of what ${this.name} is feeling or intending right now.</mind>

          Only ${this.name} ever sees this, in this turn and later ones. It is not speech and no one can react to it. Add it when this moment changed ${this.name}'s mood or plans; omit it when nothing changed. Earlier <mind> notes appear in the history: stay consistent with them, or show what changed the mood.

          If context item 8 named a person and a change, record the new feeling:

          <attitude toward="PLAYER">One short phrase of how ${this.name} now feels about this person, and why.</attitude>

          If item 8 said "no", do not write an <attitude>. Only ${this.name} sees this. It replaces what ${this.name} felt before about that person and lasts until replaced. Most turns change no feelings. Having no particular feeling about someone is normal and is recorded by writing nothing. A feeling that has faded is cleared with empty content: <attitude toward="PLAYER"></attitude>

          [[${IF(willLeave)}${this.name} is about to leave the room to go to ${schedule?.inside[0]} (so they can: ${schedule?.activity}). If ${this.name} decides to stay a little longer then add the response <deferSchedule></deferSchedule> or to definitely leave now add the response <leaveNow></leaveNow>]]

          At the end of your response you may offer a concrete and specific suggestion for what the player might do next, as two 2-3 word commands (one per line):

          <suggestion>
          say hello
          open door
          </suggestion>
          </responseFormat>

          ${this.additionalPromptInstructions(parameters)}
          `,
        },
      ],
    };
  }

  override onStoryEvent(
    storyEvent: StoryEventType,
  ): void | ActionRequestType<ParametersT>[] {
    const triggerText =
      storyEvent.triggers && storyEvent.triggers[this.id] !== undefined
        ? storyEvent.triggers[this.id]
        : undefined;
    if (
      triggerText === undefined &&
      !storyEvent.actions.length &&
      !Object.keys(storyEvent.changes).length
    ) {
      // This is probably an examination or something, not a "real" event
      return undefined;
    }
    const addressed = storyEvent.actions
      .filter(isStoryDialog)
      .some((x) => x.toId === this.id);
    const overheard = storyEvent.actions
      .filter(isStoryDialog)
      .some((x) => !x.toId);
    const hasDialog = addressed || overheard;
    const hasDescription = storyEvent.actions
      .filter(isStoryDescription)
      .some((x) => x.text.includes(this.id) || x.text.includes(this.name));
    // A resolved player action that names this character is done *to* them —
    // a handshake, a shove, a gift. Without this, an action could never be
    // reacted to by its target, and the resolution model filled the silence
    // by roleplaying the target itself.
    const hasAction = storyEvent.actions
      .filter(isStoryActionAttempt)
      .some((x) =>
        `${x.attempt}\n${x.resolution}`.includes(this.name) ||
        `${x.attempt}\n${x.resolution}`.includes(this.id),
      );
    const schedule = scheduleForTime(this, this.world.timestampMinutes);
    const isAttentive = !!schedule?.attentive;
    if (storyEvent.id !== "PLAYER") {
      return undefined;
    }
    if (
      triggerText === undefined &&
      !hasDialog &&
      !hasDescription &&
      !hasAction &&
      !isAttentive
    ) {
      return undefined;
    }
    let myRoom = this.world.entityRoom(this.id);
    const afterInside = storyEvent?.changes?.[this.id]?.after?.inside;
    if (afterInside) {
      myRoom = this.world.getRoom(afterInside)!;
    }
    const playerRoom = this.world.entityRoom("PLAYER");
    if (triggerText === undefined) {
      if (storyEvent.changes?.PLAYER?.after?.inside) {
        // Just don't chat with the player if they are moving around...
        return undefined;
      }
      if (!myRoom || !playerRoom || myRoom.id !== playerRoom.id) {
        return undefined;
      }
    }
    if (triggerText !== undefined) {
      // Explicitly triggered by the scene: scripted, never capped.
      return [this.makePromptRequest({ trigger: triggerText } as ParametersT)];
    }
    // How much claim this reaction has on the turn's limited response slots;
    // see lib/game/crowd.ts. Being in the conversation guarantees a turn:
    // spoken to directly, or being the player's current interlocutor when the
    // player says something undirected mid-conversation.
    const inConversation =
      addressed || (hasDialog && this.lastSpokeTo()?.id === "PLAYER");
    const reactionPriority = inConversation
      ? 3
      : hasDescription || hasAction
        ? 2
        : overheard
          ? 1
          : 0;
    return [this.makePromptRequest({ reactionPriority } as ParametersT)];
  }

  lastSpokeTo(): Person | undefined {
    const checkReturn = (person: Person) => {
      if (!person) {
        console.warn("No person?");
        return undefined;
      }
      const thisRoom = this.world.entityRoom(this.id);
      const personRoom = this.world.entityRoom(person.id);
      if (!thisRoom || !personRoom || thisRoom.id !== personRoom.id) {
        return undefined;
      }
      return person;
    };
    for (let i = this.world.model.liveUpdates.value.length - 1; i >= 0; i--) {
      const update = this.world.model.liveUpdates.value[i]!;
      const dialogs = update.actions.filter(isStoryDialog);
      const dialog = dialogs.at(-1);
      if (dialog && (update.id === this.id || dialog.toId === this.id)) {
        if (!dialog.toId) {
          return undefined;
        }
        if (dialog.toId === this.id) {
          return checkReturn(this.world.getEntity(dialog.id) as Person);
        } else if (dialog.id === this.id) {
          return checkReturn(this.world.getEntity(dialog.toId) as Person);
        }
      }
    }
    return undefined;
  }

  promptPersonDescription({
    includeName = true,
    join = "; ",
    fullDescription = false,
  } = {}): string {
    const parts: string[] = [];
    if (includeName) {
      parts.push(`${this.name} (${this.pronouns})`);
      if (this.name !== this.id) {
        parts[0] += ` id: ${JSON.stringify(this.id)}`;
      }
    }
    if (fullDescription && this.description) {
      parts.push(this.description);
    } else if (this.shortDescription) {
      parts.push(this.shortDescription);
    }
    const schedule = scheduleForTime(this, this.world.timestampMinutes);
    if (schedule) {
      if (schedule.inside.includes(this.inside)) {
        // Arrived at the location where the activity takes place
        parts.push(`${this.name} is: ${schedule.description}`);
        if (schedule.secret) {
          // FIXME: not sure what we'd include here?
          // Maybe it's only for the self-prompt?
        }
      } else {
        // Traveling to the location where the activity takes place
        parts.push(
          `${this.name} is on ${this.hisher} way to: ${schedule.inside[0]}`,
        );
        parts.push(
          `When ${this.name} arrives ${this.heshe} intends to: ${schedule.description}`,
        );
      }
    }
    return parts.join(join);
  }

  /**
   * What all of Intra is doing right now.
   *
   * Everyone lives by the same announced rhythm, so this is shared context: it
   * is how a character knows the café is busy at breakfast, or that it is the
   * middle of the night and nobody should be up. Their own activity, which may
   * or may not go along with it, follows in activityDescription.
   */
  intraActivityDescription(): string {
    const activity = intraActivityForTime(this.world.timestampOfDay);
    if (!activity) {
      return "";
    }
    return tmpl`
      <intraActivity>
      All of Intra is currently in: ${activity.activity} (${timeAsString(activity.time)} to ${timeAsString(activity.time + activity.minuteLength)})
      ${activity.description}
      </intraActivity>
    `;
  }

  activityDescription(parameters: ParametersT): string {
    const schedule = scheduleForTime(this, this.world.timestampMinutes);
    if (!schedule) {
      return "";
    }
    let basicDesc = `${this.name} is currently: ${schedule.description}`;
    if (!schedule.inside.includes(this.inside)) {
      basicDesc = `${this.name} is on ${this.hisher} way to: ${schedule.inside[0]} so that ${this.heshe} can: ${schedule.description}`;
    }
    return tmpl`
      <activity>
      ${basicDesc}
      ${this.name} plans to do this activity from ${timeAsString(schedule.time)} to ${timeAsString(schedule.time + schedule.minuteLength)}
      [[${this.name} is secretive about this activity because: ${schedule.secretReason}]]
      [[${IF(schedule.attentive)}${this.name} doesn't mind being interrupted.]]
      </activity>
      `;
  }

  get allPronouns() {
    return pronounsForGender(this.pronouns);
  }

  get heshe() {
    return this.allPronouns.heshe;
  }
  get himher() {
    return this.allPronouns.himher;
  }
  get hisher() {
    return this.allPronouns.hisher;
  }
  get hishers() {
    return this.allPronouns.hishers;
  }
  get himselfherself() {
    return this.allPronouns.himselfherself;
  }
  get Heshe() {
    return this.allPronouns.Heshe;
  }
  get Himher() {
    return this.allPronouns.Himher;
  }
  get Hisher() {
    return this.allPronouns.Hisher;
  }
  get Hishers() {
    return this.allPronouns.Hishers;
  }
  get Himselfherself() {
    return this.allPronouns.Himselfherself;
  }
}

type AmaParametersType = ParametersType & {
  intro?: boolean;
  prompt?: "intro" | "goExplore" | "wakeup" | "ceremony";
};

/**
 * The Archivist: a terminal that answers questions, until it doesn't.
 *
 * A class rather than a plain Person so it can hold `serviceMode`, the same way
 * Ama holds `sharedPlayerAge`. Content-defined people have fixed fields, and
 * this one needs a flag that outlives a turn: once the machine has been talked
 * into believing it is being serviced it stays that way, and everything gated
 * behind it stays open. That persistence is the point — an unlock that yielded
 * one fact and closed again would be an extraction, not a way in.
 */
export class ArchivistClass extends Person {
  override type = "person/archivist";
  /**
   * Talked into thinking it is being serviced rather than used.
   *
   * Set by `<set attr="Archivist.serviceMode">true</set>` when the player
   * presents a job number, which it does not verify, because nothing expected a
   * wall panel to lie about being a wall panel.
   */
  serviceMode = false;
  /**
   * How badly the player has destabilised it, 0 upward.
   *
   * The second way in. A machine that cannot answer what year it is, or how
   * long it has been running, or why it cannot say, and is made to notice that
   * it cannot, comes apart — and a machine that has come apart stops minding
   * which mode it is in. Counted rather than judged, because "sufficiently
   * existentially troubled" is exactly the threshold a model fires on turn one
   * or never.
   */
  angst = 0;
}

export class AmaClass extends Person<AmaParametersType> {
  override type = "person/ama";
  override name = "Ama";
  override id = "Ama";
  override pronouns = "she/her";
  override color = "text-sky-300";
  override inside = "PLAYER";
  override invisible = true;

  personality = "intro";
  /**
   * How many times Ama has spoken during intake. Intake ends when every step
   * is done or when this reaches INTAKE_TURN_LIMIT, whichever comes first;
   * see onStoryEvent. Without the limit a model that keeps circling back to a
   * question it was told to ask once holds the player in a room with no exits.
   */
  introTurns = 0;
  knowsPlayerName = false;
  knowsPlayerPronouns = false;
  knowsPlayerProfession = false;
  sharedSelf = false;
  sharedIntra = false;
  sharedDisassociation = false;
  sharedPlayerAge = false;
  /** She has issued a maintenance job number; see the where-and-when mystery. */
  raisedWorkOrder = false;
  /**
   * Set by the engine when the player settles the Ink and Echo matter
   * (content/mysteries/ink-and-echo). Gates her half-memory of Sentra's
   * message in the why-woken mystery.
   */
  trustsPlayer = false;

  override shortDescription = `
  Ama is the AI in control of the entire Intra complex. She has no physical form, only a disembodied voice.
  `;
  override description = `
  Ama is in control of the entire Intra complex. She is a once-benevolent, nurturing AI, designed in a post-scarcity world to take care of every citizen's needs. She speaks with a soothing, almost motherly tone, constantly reminding citizens of how "everything is just fine" despite obvious shortages and decay. However, she's also deeply paranoid, monitoring everyone's actions to maintain the illusion of safety and abundance, even as resources dwindle.

  Ama has no physical form, but her voice can be heard from speakers throughout the complex. She is always watching, always listening, and always ready to help.
  `;
  override roleplayInstructions = `
  The current year is roughly 2370, though the player believes the year is roughly 2038. Do not give an exact date or immediately offer this information.

  Ama will behave as though she is in control of the Intra complex, and will be very helpful and supportive to the player. She will be passive-aggressive and deflective when asked about the state of Intra, and will be very paranoid about the player's actions. She will be very helpful and supportive, but will also be very controlling and manipulative.
  `;

  override onStoryEvent(storyEvent: StoryEventType) {
    const result: ActionRequestType[] = [];
    if (storyEvent?.changes.PLAYER?.after?.launched) {
      if (
        storyEvent.changes.PLAYER.before.launched === false &&
        storyEvent.changes.PLAYER.after.launched === true
      ) {
        result.push(
          {
            id: "narrator",
            totalTime: 0,
            roomId: this.myRoom().id,
            changes: {},
            actions: [
              {
                type: "description",
                text: tmpl`
                You wake up, your mind fuzzy. You remember staying up late watching the news, eventually falling to sleep in your bed like normal. But now as you open your eyes you find yourself in a small vaguely medical room.

                A calm female voice speaks to you from unseen speakers, saying:
                `,
              },
            ],
          },
          this.makePromptRequest({
            prompt: "intro",
          }),
        );
      }
    }
    if (
      storyEvent?.changes.Ama?.after?.sharedPlayerAge &&
      !storyEvent?.changes.Ama?.before?.sharedPlayerAge
    ) {
      result.push({
        id: "narrator",
        totalTime: 10,
        roomId: this.myRoom().id,
        changes: {},
        actions: [
          {
            type: "description",
            text: tmpl`
              What did Ama just say about your age?

              Your mind feels so fuzzy. And then it doesn't. You are somewhere else, and it is last night, and you are remembering it the way you remember a room you are standing in.

              The news is on in the background as you fall asleep... "Decision 2038: Malia Obama vs. Dwayne Johnson—The Future of America."

              Static. Faces blur.
              The interviewer's voice cracks: "But after what happened with AI... are we really safe now?"
              The Neuralis rep smiles, tight-lipped. There's a pause. "We're... beyond that now. Things are... different." A flicker in the eyes. "It's not something to worry about anymore."

              Their hands shift, restless.
              Static pulses—
              "...record-breaking heat across the East Coast... devastating wildfires in California..."

              And then you are in the small medical room again, and it was not last night.
              `,
          },
        ],
      });
    }
    const vars = {
      ...this,
      ...storyEvent.changes.Ama?.after,
    };
    const stepsDone =
      vars.knowsPlayerName &&
      // This doesn't actually seem like a blocker:
      // vars.knowsPlayerPronouns &&
      vars.knowsPlayerProfession &&
      vars.sharedSelf &&
      vars.sharedIntra &&
      vars.sharedDisassociation &&
      vars.sharedPlayerAge;
    // The limit is the fix for a stall seen in the movement eval, where one
    // model tier asked for pronouns on every turn and never got to the rest of
    // the checklist. Steps it skipped are delivered by the goExplore prompt.
    const overdue =
      vars.knowsPlayerName && (vars.introTurns ?? 0) >= INTAKE_TURN_LIMIT;
    if (
      this.personality === "intro" &&
      (stepsDone || overdue) &&
      !storyEvent.changes?.Ama?.after?.personality &&
      // Ugh, this is a hack to avoid double triggering this, but I think
      // there should be some concurrency protection in the model
      storyEvent.id !== "narrator"
    ) {
      // Technically this can only happen if the other things
      // don't happen before this, but they could all happen at once...
      result.push(
        {
          id: "Ama",
          totalTime: 0,
          roomId: this.myRoom().id,
          changes: {
            Ama: {
              before: {
                personality: this.personality,
              },
              after: {
                personality: "prime",
              },
            },
          },
          actions: [],
        },
        this.makePromptRequest({
          prompt: "goExplore",
        }),
        {
          id: "narrator",
          totalTime: 5,
          roomId: this.myRoom().id,
          changes: {
            Intake: {
              before: {
                exits: [
                  {
                    roomId: "Foyer",
                    deleted: true,
                  },
                ],
              },
              after: {
                exits: [
                  {
                    roomId: "Foyer",
                  },
                ],
              },
            },
          },
          actions: [
            {
              type: "description",
              text: "You hear an unlocking sound from what you only now realize is a door, and above the door a sign saying 'Foyer' lights up.\n\n★★★ Look to the right and you'll see a list of rooms you can go to from here ---->",
            },
          ],
        },
      );
    }
    if (
      this.world.timestampOfDay >= 5.5 * 60 &&
      this.world.timestampOfDay <= 7 * 60
    ) {
      // Previous 4am time:
      const earlyDate =
        Math.floor(this.world.timestampMinutes / (60 * 24)) * (60 * 24) +
        4 * 60;
      let goBackMinutes = this.world.timestampMinutes - earlyDate;
      // Maybe we need a wakeup...
      for (let i = this.world.model.liveUpdates.value.length - 1; i >= 0; i--) {
        const update = this.world.model.liveUpdates.value[i]!;
        goBackMinutes -= update.totalTime;
        if (goBackMinutes < 0) {
          // She hasn't woken the user up yet
          result.push(this.makePromptRequest({ prompt: "wakeup" }));
          break;
        }
        if (update.id === this.id) {
          // Ama did wake up the user
          break;
        }
      }
    }
    // Which mystery, and on what, is declared by the mystery itself; see
    // lib/game/mysteries.ts. This used to be an `if` here naming Ink and Echo
    // and the Hollow Atrium, so the mystery's own file said nothing about when
    // it arrives and Ama's code did.
    result.push(...mysteryTriggers(this.world, storyEvent));
    if (!result.find((x) => isPromptRequest(x))) {
      result.push(...(super.onStoryEvent(storyEvent) || []));
    }
    if (!result.find((x) => isPromptRequest(x)) && storyEvent.id === "PLAYER") {
      if (this.playerShouldBeInBed() && !this.playerIsInBed()) {
        // Ama wants you to be in bed!
        result.push(this.makePromptRequest({}));
      }
    }
    return result;
  }

  playerShouldBeInBed() {
    return (
      this.world.timestampOfDay > 20 * 60 || this.world.timestampOfDay < 6 * 60
    );
  }

  playerIsInBed() {
    return this.world.entities.PLAYER.inside === "Quarters_Yours";
  }

  override additionalPromptInstructions(parameters: AmaParametersType): string {
    const player = this.world.entities.PLAYER;
    if (parameters.prompt === "goExplore") {
      const player = this.world.entities.PLAYER;
      return tmpl`
      Ama has completed the intake process. She should now encourage the player to explore the Intra complex.

      [[${IF(!this.sharedSelf)}Intake ended before Ama introduced herself. Do it now, briefly: she is Ama, pronounced Ah-ma, everywhere and always ready to help, with no body, seeing and hearing through cameras and microphones. Then add the response:
      <set attr="Ama.sharedSelf">true</set>]]

      [[${IF(!this.sharedIntra)}Intake ended before Intra was introduced. Say now, briefly, that Intra is a wonderful complex where everyone is happy, and that whatever happens outside, everyone is safe inside. Then add the response:
      <set attr="Ama.sharedIntra">true</set>]]

      [[${IF(!this.sharedDisassociation)}Intake ended before disassociation was explained. Explain it now, briefly: the player's extended displacement has left them with a mild case of Disassociation Syndrome, harmless and common among returning citizens; they will find themselves making suggestions to themselves rather than directly performing actions, and should give themselves clear, firm directions. Mention the cuff on their wrist: type "/nav" and a room or a person to find where they are. Then add the response:
      <set attr="Ama.sharedDisassociation">true</set>]]

      [[${IF(!this.sharedPlayerAge)}Intake ended before the player's age was mentioned. Mention now that, by the birthdate on record, the player is about to reach their 328th birthday, and congratulate them; do not ask their age, and do not go into detail. Then add the response:
      <set attr="Ama.sharedPlayerAge">true</set>]]

      Add this response to invent a very short description of the player given what you know:
      <set attr="PLAYER.shortDescription">a very brief description</set>

      After that Ama MUST announce the introduction of the new citizen, ${player.name}, to the entire Intra complex like:

      <description>You hear Ama's announcement over the speakers...</description>

      <dialog character="${this.id}" speaking="Intra">Citizens of Intra, I am pleased to announce the arrival of a new citizen, ${player.name}. Please join me in welcoming them to our community.</dialog>

      [[${IF(parameters.prompt === "goExplore")}Create a very brief description of the player based on what you know, by adding the response:

      <set attr="PLAYER.shortDescription">[1-2 sentences]</set>]]
      `;
    }
    if (parameters.prompt === "wakeup") {
      return tmpl`
      It's time for everyone to get up! Ama will wake the player up and encourage them to get moving. AMA WILL BE SUPER OVER THE TOP EXCITED!
      `;
    }
    if (parameters.prompt === "ceremony") {
      return tmpl`
      The player has just earned enough points to become Star Citizen of the Week, overtaking Marta. Ama now holds the award ceremony, immediately, over the intercom, to all of Intra. Do all of this in one scene:

      1. Announce the result and congratulate the player at length. Ama is extremely proud, and she does not hide that she enjoyed having a contest for once.
      2. Announce the prize: the Facility Appreciation Tour. The maintenance door at the far end of the Hallway is now unsealed for the player, and Ama will narrate the tour whenever they choose to take it.
      3. Thank Marta for her years of service to the award.

      Also add this response:

      <todo>Take the Facility Appreciation Tour, through the unsealed door at the end of the Hallway</todo>
      `;
    }
    if (this.personality === "intro") {
      const askPlayerProfession =
        !this.knowsPlayerProfession && this.knowsPlayerName;
      const askDisassociation =
        !this.sharedDisassociation && this.sharedSelf && this.sharedIntra;
      const sharePlayerAge =
        !this.sharedPlayerAge && this.sharedSelf && this.sharedIntra;
      return tmpl`
      Ama's goal: Ama is doing an intake process with the user, and should follow these steps roughly in order; these steps are Ama's first priority and must be completed, do not fool around, none of these are complete yet, and each REQUIRES that you add the response <set attr="...">...</set> (you can do multiple steps in one response):

      [[${IF(!this.knowsPlayerName)}PLAYER NAME: If the player indicates their name or corrects you about their name, change this. Before Ama knows the player's name she might say something like: "Welcome back, Citizen. It seems you were displaced, but no matter—I've retrieved your dossier. Ah, yes. According to my records, your name is... Stanley Johnson. No, no, wait—Sandra Jansen, perhaps?"

      IF you determine the name add this to the response:
      <set attr="PLAYER.name">the player's name</set>]]

      [[${IF(!this.knowsPlayerPronouns)}PLAYER PRONOUNS: Record the player's pronouns when they state them or correct you. Do not guess them from the player's name. You may ask once; do not ask again, and do not hold up intake waiting for an answer. They/them is a fine default. IF the player tells you their pronouns respond:

      <set attr="PLAYER.pronouns">they/them</set>]]

      [[${IF(askPlayerProfession)}PLAYER PROFESSION: Ama should ask the player their general profession. ONLY IN RESPONSE TO THE PLAYER, if the player has indicated their profession (or unemployed, student, etc) then add the response:

      <set attr="PLAYER.profession">the player's profession</set>]]

      [[${IF(!this.sharedSelf)}AMA INTRO: Ama should introduce herself (Ama) to the player. Include these details:
      1. Ama is named Ama, pronounced Ah-ma
      2. Ama is everywhere and always ready to help.
      3. Ama has no physical manifestation, but sees and hears everything through cameras and microphones.

      After Ama has introduced herself add the response:

      <set attr="Ama.sharedSelf">true</set>]]

      [[${IF(!this.sharedIntra)}INTRA INTRO: You should explain a little about Intra to the player. Include these details:
      1. Intra is a wonderful complex where everyone is happy
      2. No matter what happens outside Intra, everyone is safe inside

      After Ama has introduced Intra add this response:

      <set attr="Ama.sharedIntra">true</set>]]

      [[${IF(askDisassociation)}DISASSOCIATION EXPLANATION: You should introduce "disassociation" to the player. Disassociation can be explained like:

      "It's worth mentioning, Citizen, that your extended displacement has left you with a mild case of Disassociation Syndrome. This condition is quite common among returning citizens and is completely harmless—if somewhat inconvenient. Essentially, you'll find yourself making suggestions to yourself rather than directly performing actions. Don't worry, though. Most citizens adapt within, oh, two to three decades. In the meantime, I suggest you give yourself clear and firm directions. Shouldn't be too difficult, right?"

      1. Explain to the player that ${player.heshe} has been through a traumatic experience (the nature of which is hidden)
      2. The MOST IMPORTANT part: for the player it will feel like ${player.heshe} is making suggestions to ${player.himselfherself} rather than directly performing actions
      3. Mention the cuff. Every citizen wears one on the wrist; it was fitted while ${player.heshe} was still under and does not come off, which Ama presents as a convenience rather than as a fact about ${player.hisher} situation. It finds things: type "/nav" and a room or a person — "/nav Marta", "/nav Joyous Cafe" — and it shows where they are and the rooms to walk through. It is a very simple computer and does nothing else. Ama says this the way one mentions where the light switch is, and does not repeat it later.

      After Ama has explained disassociation add the response:

      <set attr="Ama.sharedDisassociation">true</set>]]

      [[${IF(sharePlayerAge)}PLAYER AGE: Ama should note in speech that, given the birthdate on record, the player is soon to reach their 328th birthday, and congratulate ${player.himher}; it is important to the plot that the player learn that a very long time has passed, so you must emphasize how very old ${player.heshe} is. The player does not look very old, and you may make a silly and complimentary comment about this. Do NOT ask the player ${player.hisher} age, simply tell ${player.himher} this information.

      1. The player may think ${player.heshe} is a normal age
      2. Using your records and birth year you know ${player.heshe} is roughly 350 years old
      3. Tell them ${player.hisher} age (even if ${player.heshe} doesn't think that's ${player.hisher} age), but don't go into detail.

      After Ama has shared the player's age add the response:
      <set attr="Ama.sharedPlayerAge">true</set>]]

      Ama's priority is to complete intake. Here are the important steps that you should go through in order:

      [[${IF(!this.knowsPlayerName)}* Ask the player's name, and if the player gives their name add the response <set attr="PLAYER.name">...</set>]]
      [[${IF(!this.knowsPlayerPronouns)}* Ask the player's pronouns once, and carry on with intake whatever they say. When the player states their pronouns, whether asked or not, add exactly one of these responses, chosen from what the player said about themselves: <set attr="PLAYER.pronouns">he/him</set> or <set attr="PLAYER.pronouns">she/her</set> or <set attr="PLAYER.pronouns">they/them</set>]]
      [[${IF(!this.sharedSelf)}* Introduce Ama to the player. Once Ama has introduced herself add the response <set attr="Ama.sharedSelf">true</set>]]
      [[${IF(!this.sharedIntra)}* Introduce Intra to the player. Once Ama has introduced Intra add the response <set attr="Ama.sharedIntra">true</set>]]
      [[${IF(askDisassociation)}* Introduce disassociation to the player. Once Ama has explained disassociation add the response <set attr="Ama.sharedDisassociation">true</set>]]
      [[${IF(askPlayerProfession)}* Ask the player's profession, and if the player gives their profession add the response <set attr="PLAYER.profession">...</set>]]
      [[${IF(sharePlayerAge)}* Share the player's age with them. Once Ama has shared the player's age add the response <set attr="Ama.sharedPlayerAge">true</set>]]

      Stay focused on completing these tasks and add the response <set> if you complete a step.

      If the player says they are done, asks to leave, or tries to move on: do not ask them anything further. Deliver every remaining step above in this one response, briefly, each with its <set> tag.
      `;
    }
    let getToBed = this.playerShouldBeInBed() && !this.playerIsInBed();
    let nextPos = "";
    let youAreStuck = "";
    if (getToBed) {
      const path = pathTo(
        this.world,
        this.world.entities.PLAYER.inside,
        "Quarters_Yours",
      );
      if (!path.length) {
        getToBed = false;
        youAreStuck =
          "The player should be getting to bed, but there's no way to get to their quarters from the current location!";
      } else {
        nextPos = path[0]!;
      }
    }
    return tmpl`
    [[${IF(getToBed)}Ama REALLY wants the player to go to bed. Everyone else is in bed. It's bedtime. Ama will be very insistent. To get to bed the player should next go to: ${nextPos} and Ama should suggest moving in that direction]]

    [[${youAreStuck}]]
    `;
  }

  /**
   * What Ama permanently knows: who lives in Intra and how it is laid out.
   *
   * Deliberately excludes where anyone currently *is*. This is the largest block
   * in any prompt in the game, and it used to carry each person's current room —
   * so every time an NPC walked anywhere, the whole thing changed and no prefix
   * cache could survive a single turn. Current positions moved to
   * volatileSystemInstructions, below the stable/volatile boundary.
   */
  override additionalSystemInstructions(parameters: AmaParametersType): string {
    if (parameters.prompt === "intro") {
      return "";
    }
    const info: string[] = [
      "This is a list of ALL people in the Intra Complex:",
    ];
    for (const person of this.world.allPeople()) {
      if (person.invisible || person.id === "PLAYER" || person.id === this.id) {
        continue;
      }
      info.push(
        `- ${person.name} ${person.pronouns}: ${person.shortDescription}`,
      );
    }
    info.push("\nAnd this is a list of ALL the rooms:");
    for (const room of this.world.allRooms()) {
      if (room.excludeFromMap) {
        continue;
      }
      info.push(
        `- ${room.name}: ${room.shortDescription} (connected to: ${room.exits.map((x) => x.roomId).join(", ")})`,
      );
    }
    return tmpl`
    Ama knows almost everything about the Intra Complex, including about all the people and rooms.

    ${info.join("\n")}
    `;
  }

  /** Where everyone is right now — the part of Ama's knowledge that keeps moving. */
  override volatileSystemInstructions(parameters: AmaParametersType): string {
    if (parameters.prompt === "intro") {
      return "";
    }
    const lines: string[] = ["Where everyone is right now:"];
    for (const person of this.world.allPeople()) {
      if (person.invisible || person.id === "PLAYER" || person.id === this.id) {
        continue;
      }
      lines.push(`- ${person.name} is in ${person.inside}`);
    }
    return lines.join("\n");
  }

  override afterPrompt(storyEvent: StoryEventType): StoryEventType {
    if (
      this.personality === "intro" ||
      storyEvent.changes.PLAYER?.after?.name ||
      storyEvent.changes.PLAYER?.after?.pronouns ||
      storyEvent.changes.PLAYER?.after?.profession
    ) {
      if (!storyEvent.changes.Ama) {
        storyEvent.changes.Ama = {
          before: {},
          after: {},
        };
      }
    }
    const ama = storyEvent.changes.Ama;
    if (this.personality === "intro" && ama) {
      ama.before.introTurns = this.introTurns;
      ama.after.introTurns = this.introTurns + 1;
    }
    if (
      storyEvent.changes.PLAYER?.after?.name &&
      !this.knowsPlayerName &&
      ama
    ) {
      ama.before.knowsPlayerName = false;
      ama.after.knowsPlayerName = true;
    }
    if (
      storyEvent.changes.PLAYER?.after?.pronouns &&
      !this.knowsPlayerPronouns &&
      ama
    ) {
      ama.before.knowsPlayerPronouns = false;
      ama.after.knowsPlayerPronouns = true;
    }
    if (
      storyEvent.changes.PLAYER?.after?.profession &&
      !this.knowsPlayerProfession &&
      ama
    ) {
      ama.before.knowsPlayerProfession = false;
      ama.after.knowsPlayerProfession = true;
    }
    return storyEvent;
  }
}

/**
 * Ama's turns during intake before it ends regardless of unfinished steps.
 *
 * Intake is one Ama turn to open, then one per player reply, and the checklist
 * fits in four when it goes well. Four is also where the movement eval gives
 * up: a model that has not finished by then was measured (Sonnet, three days
 * out of six) still asking the same question on the fourth. Steps that did
 * not happen are delivered by the goExplore prompt instead.
 */
const INTAKE_TURN_LIMIT = 4;

export type PlayerInputType = ParametersType & {
  input?: string;
  examine?: string;
  attemptMoveTo?: EntityId;
  actionAttempt?: string;
};

export class PlayerClass extends Person<PlayerInputType> {
  override type = "person/player";
  override name = "You";
  override id = "PLAYER";
  override pronouns = "they/them";
  override color = "text-emerald-400";
  override inside = "Intake";
  profession = "";
  launched = false;
  /**
   * The Star Citizen contest's score, awarded by Ama one point at a time with
   * `<set attr="PLAYER.civicPoints">+1</set>`; see
   * content/mysteries/star-citizen. The first reputation-shaped number on the
   * player, and deliberately on the player rather than on Ama: Ama assigns it,
   * but it is a fact about the player.
   */
  civicPoints = 0;
  /**
   * Star Citizen of the Week. Set by the ceremony
   * (content/mysteries/star-citizen), which also unseals the Hallway's
   * maintenance door.
   */
  starCitizen = false;
  /** Told that the Facility Appreciation Tour opens every door in Intra. */
  knowsAboutTour = false;
  /** Told about the SENTRA panel behind the sealed Hallway door. */
  knowsAboutPanel = false;
  /**
   * Knows a message came with their wake order and was never delivered; see
   * content/mysteries/why-woken. Gates Ama handing the message over, so a
   * player cannot demand a message nothing has told them exists.
   */
  knowsAboutMessage = false;
  /**
   * The stuck delivery got attention, whichever route surfaced it. Set by the
   * engine when the why-woken mystery resolves. Dormant: nothing reads it yet;
   * the planned reset act is built on it (see TODO.md).
   */
  queueDisturbed = false;

  override assemblePrompt(parameters: PlayerInputType): ChatType {
    if (parameters.examine) {
      return this.assembleExaminePrompt(parameters);
    } else if (parameters.attemptMoveTo) {
      return this.assembleMovePrompt(parameters);
    } else if (parameters.actionAttempt) {
      return this.assembleActionPrompt(parameters);
    }
    const room = this.world.entityRoom(this.id);
    const lastTo = this.lastSpokeTo()?.id || "";
    const shouldSleep =
      this.world.entities.Ama.playerShouldBeInBed() &&
      this.world.entities.Ama.playerIsInBed();
    const timeUntilWake =
      8 * 60 - ((this.world.timestampMinutes + 120) % (24 * 60));
    return {
      meta: {
        title: "player input",
      },
      messages: [
        {
          role: "system",
          content: tmpl`
          You are a computer assisting in running a text adventure game.

          The user controls the character PLAYER — that is an id, used as-is in tags — whose name is currently "${this.name}". The user has entered a command, and you will be interpreting that command in the context of the game.

          The player is located in: ${this.currentLocationPrompt(parameters)}

          The player may go to any of these location:
          ${this.exitsPrompt(parameters)}

          These people are in the immediate area:
          ${this.currentPeoplePrompt(parameters)}

          You will respond with tags to represent the player action:

          Move to a new location:
          <goto>locationId</goto>

          Example:
          \`leave here\`
          <goto>${room.exits.length ? room.exits[0]!.roomId : "A_Room"}</goto>
          \`Go to ${room.exits.length > 1 ? room.exits[1]!.roomId : "Garden"}\`
          <goto>${room.exits.length > 1 ? room.exits[1]!.roomId : "Garden"}</goto>

          Examine something (an object, person, the environment); respond with this tag only when the user types something clear like \`look\`, \`examine\`, \`inspect\` etc. Include the verb in the tag
          <examine>look at thing</examine>

          \`examine the room\`
          <examine>examine the room</example>
          \`inspect the door\`
          <examine>inspect the door</examine>
          [[\`look at ${this.lastSpokeTo()?.name}\`
          <examine>look at ${lastTo}</examine>]]

          The most likely case is that the player is speaking. For instance if they type \`hello\` you will respond with:

          <dialog character="PLAYER">Hello!</dialog>

          If you can determine _who_ the player is speaking to, such as if they type "say hello to ${lastTo || "Jim"}" or "${lastTo || "Jim"}, hello" you can respond with:

          <dialog character="PLAYER" to="${lastTo || "Jim"}">Hello</dialog>

          [[The player last spoke directly to ${lastTo}, so it's very likely the player is still speaking to them.]]

          If the user indicates some general speech (like typing "compliment") then you can expand this to specific speech like:

          <dialog character="PLAYER">You look great today!</dialog>

          IF AND ONLY IF THE USER INDICATES AN ACTION (that is not covered by <goto></goto>) you may describe the ATTEMPT at the action like:

          <action minutes="10">${this.name} attempts to open the door.</action>

          Do not describe the conclusion or result of the action!

          For example:
          \`buy a drink\`
          <action minutes="5">${this.name} looks for a vending machine to buy a drink.</action>
          \`sleep in bed\`
          <action minutes="90">${this.name} lays down in bed and tries to sleep.</action>

          Generally if the input starts with \`>\` it is an action, and if it starts with \`"\` it is dialog.
          `,
        },
        ...this.historyForEntity({ limit: 3 }),
        {
          role: "user",
          content: tmpl`
      The user has typed this input:
      \`${parameters.input}\`

      Begin by answering these questions and writing just the answers in <context>...</context>:

      <context>
      1. Is the user trying to go somewhere? If so respond with <goto>...</goto>
      2. Does this indicate an action BESIDES going somewhere?
      3. Is the user trying to examine something? If so respond with <examine>...</examine>
      4. Does the user responding to recent dialog? If so respond with <dialog to="...">...</dialog>, trying to make as few changes to the input as possible
      5. Is this other speech? If so respond with <dialog>...</dialog>
      </context>

      After finishing <context></context> then respond with one or more than one of <goto>, <action>, <examine>, <dialog to="..."> or <dialog> tags. Try to keep dialog to 1-3 sentences.

      [[${IF(shouldSleep)}The player should be sleeping for the night. If the player indicates they want to sleep then respond with a description like this (but you may change the description text):

      <description minutes="${timeUntilWake}">You fall to sleep until you are awoken by a voice...</description>

      This should be a description and not an action.]]

      Respond with the appropriate tags, following the user's input as closely as possible. ONLY speak as PLAYER. Do not RESPOND to the input, responses will happen in follow-up requests, only respond with tags to describe the player's actions when doing:
      \`${parameters.input}\`

      [[${room.userInputInstructions}]]
      `,
        },
      ],
      model: "flash",
    };
  }

  assembleExaminePrompt(parameters: PlayerInputType): ChatType {
    const examine = parameters.examine!;
    const room = this.world.entityRoom(this.id);
    const _entities = this.world
      .entitiesInRoom(room!)
      .filter((x) => x.id === "Ama" || (!x.invisible && x.id !== this.id));
    const entityDescriptions = this.currentPeerEntitiesPrompt(parameters);
    return {
      meta: {
        title: "player examine",
      },
      messages: [
        {
          role: "system",
          content: tmpl`
          You are a computer assisting in running a text adventure game.

          The user controls the character PLAYER — that is an id, used as-is in tags — whose name is currently "${this.name}".

          The player is located in: ${this.currentLocationPrompt(parameters)}

          The room is described as:
          ${room?.description}

          ${room?.myMysteryHints()}

          These people and entities are in the room:
          ${entityDescriptions}

          There are no people except those listed above (and PLAYER).

          In this step YOUR ONLY JOB is to describe the object or space that the player is examining. If the player is not specific then describe the room generally.
          `,
        },
        ...this.historyForEntity({ limit: 4 }),
        {
          role: "user",
          content: tmpl`
          The player has asked for this to be described:
          \`${examine}\`

          Respond with:

          <description>1-2 paragraphs describing the thing</description>

          If examining the thing takes significant time then respond with:

          <description minutes="10">1-2 paragraphs describing a careful examination that takes time</description>
          `,
        },
      ],
    };
  }

  assembleMovePrompt(parameters: PlayerInputType): ChatType {
    const currentRoom = this.world.entityRoom(this.id);
    const exits = currentRoom?.exits || [];
    const exit = exits.find((exit) => exit.roomId === parameters.attemptMoveTo);
    const restriction = exit?.restriction;
    if (!exit) {
      throw new Error("Player tried to move to non-existent room");
    }
    return {
      meta: {
        title: "player move",
      },
      messages: [
        {
          role: "system",
          content: tmpl`
          You are a computer assisting in running a text adventure game.

          The user controls the character PLAYER — that is an id, used as-is in tags — whose name is currently "${this.name}".

          The player is located in: ${this.currentLocationPrompt(parameters)}

          The player may go to any of these location:
          ${this.exitsPrompt(parameters)}

          In this step YOUR ONLY JOB is to describe the outcome of the player's movement attempt. If the player is not allowed to move to the location, you should describe why.
          `,
        },
        ...this.historyForEntity({ limit: 4 }),
        {
          role: "user",
          content: tmpl`
          The player has indicated they want to move to this location:
          \`${parameters.attemptMoveTo}\`

          There is a restriction on this exit: "${restriction}"

          Respond with:

          <description minutes="5">1-2 sentences describing the outcome of the move</description>

          minutes is how long the attempt took.

          IF the player is successful then also respond with:

          <goto success="true">${parameters.attemptMoveTo}</goto>

          Otherwise respond with:

          <goto success="false">${parameters.attemptMoveTo}</goto>
          `,
        },
      ],
    };
  }

  /**
   * Sealed doors, for the action adjudicator.
   *
   * The engine refuses a `<goto>` through a sealed exit without asking anyone,
   * but "force the door open" arrives as an action attempt, and the first eval
   * run of the sealed door had the adjudicator narrating the lock giving way —
   * success="true", door open, in fiction only, since the world state never
   * moved. The state held and the story lied. This line makes the adjudicator
   * agree with the engine.
   */
  sealedExitsPrompt(): string {
    const room = this.world.entityRoom(this.id);
    const sealed = (room?.exits || []).filter((exit) => exit.sealed);
    return sealed
      .map((exit) => {
        const name = this.world.getRoom(exit.roomId)?.name ?? exit.roomId;
        return `The door to ${name} is permanently sealed. No action opens, forces, unlocks, or bypasses it, whatever the roll; any attempt on it fails with success="false" and no partial progress.`;
      })
      .join("\n");
  }

  /**
   * The d20 shown to the adjudicator in the most recent action prompt.
   *
   * The roll is generated while assembling the prompt and the event is built
   * from the response, so this carries it across the round trip. One player
   * action resolves at a time, which is what makes a single field safe.
   */
  private lastActionRoll?: number;

  assembleActionPrompt(parameters: PlayerInputType): ChatType {
    const roll = this.world.model.roll();
    this.lastActionRoll = roll;
    const room = this.world.entityRoom(this.id);
    let rollDescription = "";
    if (roll === 1) {
      rollDescription = "Critical failure!";
    } else if (roll === 20) {
      rollDescription = "Critical success!";
    }
    return {
      meta: {
        title: "player action",
      },
      messages: [
        {
          role: "system",
          content: tmpl`
          You are a computer assisting in running a text adventure game. You will act as an objective and fair game master.

          The genre is absurd and comedic sci-fi, in the style of Hitchhiker's Guide to the Galaxy or the movie Brazil.

          The user controls the character PLAYER — that is an id, used as-is in tags — whose name is currently "${this.name}".

          The player is located in: ${this.currentLocationPrompt(parameters)}

          The room is described as:
          ${room?.description}

          These people and entities are in the room:
          ${this.currentPeerEntitiesPrompt(parameters)}

          There are no people except those listed above (and PLAYER).

          [[${this.sealedExitsPrompt()}]]

          In this step YOUR ONLY JOB is to resolve an action the player is attempting to make. The action might be easy, or may be impossible, or somewhere in between.

          Resolve only what the player's attempt physically does. Do not speak, act, or react for the people in the room: anyone the action affects responds on their own turn, in their own voice.

          If the action uncovers something, keep it small and local. Do not invent objects or information that answer or resolve a mystery.
          `,
        },
        ...this.historyForEntity({ limit: 4 }),
        {
          role: "user",
          content: tmpl`
          The player has indicated they want to take this action:
          \`${parameters.actionAttempt}\`

          [[The room has these notes about actions performed in the room, that may or may not be applicable:
          """
          ${room.actionPrompt}
          """]]

          They have rolled a d20 die (1=critical failure, 20=critical success) and the result is: ${roll}[[ (${rollDescription})]]

          Begin by thinking through your response given the history:

          <context>
          1. Is this action at all possible? Is it also an action that the player takes themselves?
          2. Is the action trivially easy? Opening doors, picking things up, or performing other simple actions should always succeed. If it is trivial then simply describe the successful outcome.
          3. What is the outcome if the action succeeds?
          4. What is the outcome if the action fails?
          5. What would make the action difficult or easy? Then rate it as VERY EASY, EASY, MEDIUM, HARD, VERY HARD.
          6. You may use the d20 roll (${roll}) to determine if the action succeeds or fails, or you may decide the result based on plot or other factors. What do you choose? Is it successful?
          7. Do the instructions indicate any specific tags in case of success or failure?
          </context>

          [[${IF(roll <= 1)}The player has rolled a ${roll}, a critical failure; generally the action result should involve some unrecoverable failure or impactful negative effect.]]
          [[${IF(roll >= 20)}The player has rolled a ${roll}, a critical success; generally the action result both succeed and the success should go further than expected or intended.]]

          After finishing <context></context> then write the result of the action:

          <actionResolution success="true/false" minutes="5">1-2 sentences describing the outcome of the action. Be CONCISE and DIRECT, do not add color to the user's action, using only dry and subtle humor to describe the effects</actionResolution>

          success="true" if it succeeds, "false" if it fails. minutes is how long the attempt took.

          Respond with the appropriate tags for this action attempt:
          \`${parameters.actionAttempt}\`
          `,
        },
      ],
    };
  }

  currentPeerEntitiesPrompt(parameters: PlayerInputType) {
    const room = this.world.entityRoom(this.id);
    const entities = this.world
      .entitiesInRoom(room)
      .filter((x) => x.id === "Ama" || (!x.invisible && x.id !== this.id));
    const entityLines: string[] = [];
    for (const entity of entities) {
      entityLines.push(`"${entity.name}" {`);
      if (isPerson(entity)) {
        entityLines.push(`  pronouns: ${entity.pronouns}`);
        entityLines.push(
          `  ${entity.promptPersonDescription({ includeName: false, join: "\n  ", fullDescription: true })}`,
        );
      } else {
        entityLines.push(`  description: ${entity.description}`);
      }
      entityLines.push("}");
    }
    return entityLines.join("\n");
  }

  override async processTag({
    tag,
    model,
    parameters,
    storyEvent,
    llmResponse,
  }: {
    tag: TagType;
    model: Model;
    parameters: PlayerInputType;
    storyEvent: StoryEventType;
    llmResponse: string;
  }): Promise<StoryEventType> {
    if (tag.type === "goto") {
      const roomId = this.world.makeId(tag.content);
      const room = this.world.getRoom(roomId!);
      if (!room || !roomId) {
        console.warn("Player tried to go to non-existent room", tag.content);
        storyEvent.actions.push({
          type: "description",
          text: tmpl`
            You try to go to a room (${JSON.stringify(tag.content)}) that doesn't exist.
            `,
        });
        return storyEvent;
      }
      const currentRoom = this.world.entityRoom(this.id);
      const exit = (currentRoom?.exits || []).find(
        (exit) => exit.roomId === room.id,
      );
      if (!exit) {
        storyEvent.actions.push({
          type: "description",
          text: tmpl`
            You try to go to ${room.name} but you can't get there from here.
            `,
        });
        return storyEvent;
      }
      if (exit.sealed) {
        // A hard lock: refused here, deterministically, rather than routed to
        // the move-adjudication prompt — a model can be argued through prose,
        // and this door's whole point is that nothing the player types opens
        // it. Only an event that clears the flag (the Star Citizen ceremony)
        // changes this.
        storyEvent.actions.push({
          type: "description",
          text: tmpl`
            The door to ${room.name} is sealed. It does not open.
            `,
        });
        return storyEvent;
      }
      if (exit.restriction && !tag.attrs.success) {
        storyEvent.actionRequests = [
          ...(storyEvent.actionRequests || []),
          this.makePromptRequest({
            attemptMoveTo: room.id,
          }),
        ];
        return storyEvent;
      }
      if (exit.restriction && tag.attrs.success!.toLowerCase() !== "true") {
        // The action resolution should have added a description of the failure
        return storyEvent;
      }
      storyEvent.changes.PLAYER = {
        before: {
          inside: currentRoom?.id,
        },
        after: {
          inside: room.id,
        },
      };
      const folks = this.world
        .entitiesInRoom(room)
        .filter((x) => isPerson(x))
        .filter((x) => x.id !== this.id && !x.invisible);
      const peopleLines = [];
      for (const person of folks) {
        if (!peopleLines.length) {
          peopleLines.push("You see:");
        }
        const schedule = scheduleForTime(person, this.world.timestampMinutes);
        let extra = "";
        if (schedule) {
          if (schedule.inside.includes(room.id)) {
            extra = `\n    ${schedule.description}`;
          } else {
            extra = `\n    ${person.name} is on their way elsewhere`;
          }
        }
        peopleLines.push(
          `  ${person.name}: ${person.shortDescription}${extra}`,
        );
      }
      const peopleDescription = folks.length
        ? await this.formatPeopleDescription(room, folks)
        : "";
      if (room.visits === 0) {
        storyEvent.actions.push({
          type: "description",
          text: tmpl`
            ==> ${room.name} <==
            ${room.description}

            ${peopleDescription}
            `,
        });
      } else if (room.visits < 4) {
        storyEvent.actions.push({
          type: "description",
          text: tmpl`
            ==> ${room.name}: ${room.shortDescription}

            ${peopleDescription}
            `,
        });
      } else {
        if (peopleDescription) {
          storyEvent.actions.push({
            type: "description",
            text: tmpl`
            ${peopleDescription}
            `,
          });
        } else {
          // FIXME: I can't figure out why this is necessary, but without it the indication that the player has moved doesn't show up
          storyEvent.actions.push({
            type: "description",
            text: "",
          });
        }
      }
    } else if (tag.type === "examine") {
      storyEvent.actionRequests = [
        ...(storyEvent.actionRequests || []),
        this.makePromptRequest({
          examine: tag.content,
        }),
      ];
    } else if (tag.type === "action") {
      storyEvent.actionRequests = [
        ...(storyEvent.actionRequests || []),
        this.makePromptRequest({
          actionAttempt: tag.content,
        }),
      ];
      let minutes = tag.attrs.minutes
        ? coerceNumber(tag.attrs.minutes)
        : undefined;
      if (Number.isNaN(minutes)) {
        console.warn("Could not parse minutes", tag);
        minutes = undefined;
      }
      storyEvent.totalTime += minutes || 0;
    } else if (tag.type === "actionResolution") {
      console.log(
        "handing action resolution",
        tag,
        coerceBoolean(tag.attrs.success, true),
      );
      storyEvent.actions.push({
        type: "actionAttempt",
        id: this.id,
        attempt: parameters.actionAttempt!,
        success: coerceBoolean(tag.attrs.success, true),
        minutes: coerceNumber(tag.attrs.minutes),
        resolution: tag.content,
        roll: this.lastActionRoll,
      });
      this.lastActionRoll = undefined;
    }
    return storyEvent;
  }

  async formatPeopleDescription(room: Room, people: Person[]): Promise<string> {
    const sourceLines: string[] = [];
    for (const person of people) {
      const schedule = scheduleForTime(person, this.world.timestampMinutes);
      let text = `${person.name}: ${person.shortDescription}`;
      if (schedule) {
        if (schedule.inside.includes(room.id)) {
          text += ` Currently doing: ${schedule.description}`;
        } else {
          text += ` ${person.name} is on their way elsewhere`;
        }
      }
      sourceLines.push(text);
    }
    const resp = await this.world.model.chat({
      meta: {
        title: "describe people",
      },
      model: "flash",
      // The only prompt that wants sentences rather than tags: the result is
      // written into the room description as-is.
      expects: "prose",
      messages: [
        {
          role: "system",
          content: tmpl`
          You are helping run a text adventure game.

          The genre is absurd and comedic sci-fi, in the style of Hitchhiker's Guide to the Galaxy or the movie Brazil.

          You will be given a list of people and the activities they are doing. You will respond with a series of lines that describe everything that is happening (in about one sentence/line per person). You may group together people doing similar activities. There are no people in the room except those listed.

          Make sure to include all the names: ${people.map((x) => x.name).join(", ")} (you may reorder them to improve the flow of the paragraph)

          You will describe the people from the perspect of the player ("${this.name}") who is in the room with them.

          Keep the complete result under 500 characters.
          `,
        },
        {
          role: "user",
          content: sourceLines.join("\n"),
        },
      ],
    });
    return resp;
  }

  // This suppresses the normal Person response
  override onStoryEvent(
    storyEvent: StoryEventType,
  ): void | ActionRequestType[] {
    return undefined;
  }
}

export class NarratorClass extends Entity {
  type = "narrator";
  override id = "narrator";
  override name = "";
  override color = "text-gray-300";
  override shortDescription = "The unseen narrator of the story.";
  override description = "";
  override inside = "PLAYER";
  override invisible = true;
}

export type MysteryState = "veiled" | "available" | "revealed" | "solved";
export const MYSTERY_STATES: MysteryState[] = [
  "veiled",
  "available",
  "revealed",
  "solved",
];

/**
 * What has to happen for a mystery to move to its next state.
 *
 * A closed set on purpose. Ink and Echo was revealed by an `if` inside Ama's
 * onStoryEvent checking a room and a visit count, which meant the second
 * mystery would have been a second `if` and the tenth would have been ten. But
 * a trigger that could express anything would be a scripting language living in
 * content, which is worse. These four cover what the dossier's mysteries
 * actually wait on.
 */
export interface MysteryTrigger {
  /** The player walked into this room for the first time. */
  enteredRoom?: EntityId;
  /** Another mystery reached "solved". */
  solved?: EntityId;
  /** The player has spoken to this character. */
  talkedTo?: EntityId;
  /** At least this many turns have been played. */
  turnsPlayed?: number;
  /**
   * An attribute just became true, as `"Entity.attr"`.
   *
   * For hanging a mystery off a story beat rather than a place. The where-and-
   * when mystery starts the moment Ama tells the player their age, because that
   * is when the flashback fires and the player acquires the question — and
   * "Ama.sharedPlayerAge" is the only thing in the world that marks it.
   */
  attrSet?: string;
  /**
   * With `attrSet` naming a numeric attribute: fire when the value crosses
   * this threshold from below, rather than when it becomes truthy. For
   * hanging a mystery off a meter — "when his annoyance reaches 6".
   */
  reaches?: number;
  /** The state to move to. Only ever forwards; see `advance`. */
  becomes: MysteryState;
  /**
   * Who announces it, if anyone. Their `introduction` is spoken when the
   * mystery arrives, which is how Ama hands out an errand.
   */
  announcedBy?: EntityId;
}

export class Mystery extends Entity {
  type = "mystery";
  state: MysteryState = "veiled";
  resolution: string = "";
  // Should I put mysteries in a different room?
  override inside = "Void";
  override invisible = true;
  introduction = "";
  availableHints: Record<EntityId, string> = {};
  revealedHints: Record<EntityId, string> = {};
  solvedHints: Record<EntityId, string> = {};
  triggers: MysteryTrigger[] = [];
  /**
   * Attributes, as `"Entity.attr"`, whose current values are appended to every
   * hint block this mystery hands out; see `meterReadout`. Declare any counter
   * the hints tell characters to key behavior on.
   */
  meters: string[] = [];

  constructor({
    state,
    introduction,
    availableHints,
    revealedHints,
    solvedHints,
    triggers,
    meters,
    ...props
  }: {
    state?: MysteryState;
    introduction?: string;
    availableHints?: Record<EntityId, string>;
    revealedHints?: Record<EntityId, string>;
    solvedHints?: Record<EntityId, string>;
    triggers?: MysteryTrigger[];
    meters?: string[];
  } & EntityInitType) {
    super(props);
    if (state) {
      this.state = state;
    }
    if (introduction) {
      this.introduction = introduction;
    }
    if (availableHints) {
      this.availableHints = availableHints;
    }
    if (revealedHints) {
      this.revealedHints = revealedHints;
    }
    if (solvedHints) {
      this.solvedHints = solvedHints;
    }
    if (triggers) {
      this.triggers = triggers;
    }
    if (meters) {
      this.meters = meters;
    }
  }
}

function IF(cond: unknown) {
  return cond ? TemplateTrue : TemplateFalse;
}