plotcoder-board 0.1.19 → 0.1.21

package/README.md

@@ -41,7 +41,7 @@ Every board verb goes through one command kernel, `src/board/reducer.js`, and th
 
 - **The wall.** Tap the words to type, drag the paper to move. Lasso to select, then Group. Drag a card's handle onto another card for an arrow. ⌘Z takes back any change, whichever door made it.
 - **`window.plotcoder`** on the page, for a console or a CDP session.
-- **The MCP server**, published to npm as `plotcoder-board`: `npx -y plotcoder-board@latest` is the server, `npx -y plotcoder-board@latest call <tool> '{json}'` one call from a shell, `npx -y plotcoder-board@latest serve` the hosted door on a port (a `Dockerfile` is here too). Inside the repo it is `scripts/plotcoder-mcp.mjs`, wired for Cursor in `.cursor/mcp.json` and for Claude Code in `.mcp.json` (run `npm ci` once first). A version tag (`v0.2.0`) publishes it, with `NPM_TOKEN` in the repo's secrets. Eighty tools: reading (`list_board`, `read_wall`, `read_pages`, `read_character`, `page_count`, `list_words`, `list_workflows`, `segment_brief`, `compare_structure`); the card, cast, place and when (`set_when`), group (with `add_to_group`) and arrow verbs, `set_logline`, `set_target`, `set_rank`, `set_plant`, `write_scene`, `edit_scene`, `move_scene`, `organize`, `apply_template` with `list_structures`, `save_structure`, `remove_structure`; `leave_question` and `ask_again`; `undo` and `redo`; the project's `list_boards`, `open_board`, `new_board`, `rename_board`, `delete_board`, `set_premise`, `rename_project` and the reminders; Fountain and Final Draft both ways, Markdown and plain text out (`export_markdown`, `export_text`); the production half (`lock_numbers`, `unlock_numbers`, `start_revision`, `end_revision`); the project as a file both ways (`export_project`, `import_project`); and, through the account door, `list_projects`, `open_project`, `new_project`, `delete_project`, `empty_account`, `delete_account`, `add_picture`, `add_take`, `list_takes`, `list_files`, `remove_file`, `build_segment`. If the dev app is open, a tool call lands on the wall within a second; if not, it edits the board file and the wall catches up on the next load.
+- **The MCP server**, published to npm as `plotcoder-board`: `npx -y plotcoder-board@latest` is the server, `npx -y plotcoder-board@latest call <tool> '{json}'` one call from a shell, `npx -y plotcoder-board@latest serve` the hosted door on a port (a `Dockerfile` is here too). Inside the repo it is `scripts/plotcoder-mcp.mjs`, wired for Cursor in `.cursor/mcp.json` and for Claude Code in `.mcp.json` (run `npm ci` once first). A version tag (`v0.2.0`) publishes it, with `NPM_TOKEN` in the repo's secrets. Eighty-one tools: reading (`list_board`, `read_wall`, `read_pages`, `read_character`, `page_count`, `list_words`, `list_workflows`, `segment_brief`, `compare_structure`); the card, cast, place and when (`set_when`), group (with `add_to_group`) and arrow verbs, `set_logline`, `set_target`, `set_rank`, `set_plant` (with `later` and `at`) and `set_payoff`, `write_scene`, `edit_scene`, `move_scene`, `organize`, `apply_template` with `list_structures`, `save_structure`, `remove_structure`; `leave_question` and `ask_again`; `undo` and `redo`; the project's `list_boards`, `open_board`, `new_board`, `rename_board`, `delete_board`, `set_premise`, `rename_project` and the reminders; Fountain and Final Draft both ways, Markdown and plain text out (`export_markdown`, `export_text`); the production half (`lock_numbers`, `unlock_numbers`, `start_revision`, `end_revision`); the project as a file both ways (`export_project`, `import_project`); and, through the account door, `list_projects`, `open_project`, `new_project`, `delete_project`, `empty_account`, `delete_account`, `add_picture`, `add_take`, `list_takes`, `list_files`, `remove_file`, `build_segment`. If the dev app is open, a tool call lands on the wall within a second; if not, it edits the board file and the wall catches up on the next load.
 - **The account door.** With `PLOTCODER_EMAIL` and `PLOTCODER_PASSWORD` in the agent's environment — the writer's own — and no dev app answering, the same server works the writer's project on the account directly, and every change lands live on every open wall. `PLOTCODER_PROJECT` picks a project by name or id. No account yet? `claim_account` makes one with the writer's email and a password they chose. The on-ramp — the doors, what to call first, the rules — is in the app behind *Are you an agent? Start here* and served at [plotcoder.com/llms.txt](https://plotcoder.com/llms.txt), both from `src/board/agents.js`.
 
 An agent should call the tools, never fake mouse drags. The skill in `.cursor/skills/plotcoder-board/SKILL.md` says how; `.claude/skills/plotcoder-board` is a symlink to the same file.
@@ -51,10 +51,10 @@ An agent should call the tools, never fake mouse drags. The skill in `.cursor/sk
 A **blind run** is a fresh agent given the on-ramp and a treatment and nothing
 else, asked to build a wall and to keep a log of everything that made the job
 harder than it should have been. The friction log is the product; the wall is
-just what produces it. Fourteen rounds have been run, the first three through a
+just what produces it. Fifteen rounds have been run, the first three through a
 repo checkout and the rest through the account door; every finding from the
-first thirteen is fixed or decided, and round fourteen's forty-nine were
-worked through the day after it ran. [`blind-runs/`](blind-runs/) holds the rules that keep a round honest,
+first fourteen is fixed or decided, and thirty-four of round fifteen's
+forty-five were fixed the same evening, while it ran. [`blind-runs/`](blind-runs/) holds the rules that keep a round honest,
 the table of rounds, and the next round's prompt with the test account filled in.
 
 A round works a **test account** — a throwaway marked on its writer row, and the
@@ -99,4 +99,4 @@ next round into a test of `claim_account` instead of the door it meant to test.
 
 ## Status
 
-Version 0.1.19. A project of boards; sign in with your email and a password from the PlotCoder mark and your projects follow you to every device, share one with another writer by email and write it together live, or stay signed out and work on this device as before. Pages sit beside the wall: a scene's text lives on its card, measures it, paginates to the industry's rules, prints, goes out and comes in as Fountain or Final Draft, and goes out as Markdown or plain text for a collaborator in Google Docs. It installs as a progressive web app and opens offline; plotcoder.com serves over HTTPS. The wall, beats, card length, groups, arrows, pan and zoom, save and open, and the agent surface are in use.
+Version 0.1.21. A project of boards; sign in with your email and a password from the PlotCoder mark and your projects follow you to every device, share one with another writer by email and write it together live, or stay signed out and work on this device as before. Pages sit beside the wall: a scene's text lives on its card, measures it, paginates to the industry's rules, prints, goes out and comes in as Fountain or Final Draft, and goes out as Markdown or plain text for a collaborator in Google Docs. It installs as a progressive web app and opens offline; plotcoder.com serves over HTTPS. The wall, beats, card length, groups, arrows, pan and zoom, save and open, and the agent surface are in use.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plotcoder-board",
-  "version": "0.1.19",
+  "version": "0.1.21",
   "type": "module",
   "scripts": {
     "dev": "vite",

package/scripts/plotcoder-mcp-server.mjs

@@ -33,6 +33,7 @@ import {
   NOTE_WIDTH,
   DEFAULT_TARGET_EIGHTHS,
   normalizeState,
+  newId,
   noteEighths,
   NOTE_COLORS,
   NOTE_RANKS,
@@ -72,6 +73,8 @@ import {
   reidentifyProject,
   renameProject,
   castElsewhere,
+  landingsOn,
+  laterBoards,
   liftCast,
   mergeRoster,
   sameRoster,
@@ -564,7 +567,40 @@ async function throughAccount(read) {
   throw new DoorReply(accountRefusal ?? "The account door is shut.");
 }
 
+/** The project as last read, so any reading of the open board can know who is cast on another board (R51) without a second read. */
+let lastHeld = null;
 async function readProject() {
+  const held = await readProjectUncached();
+  lastHeld = held;
+  return held;
+}
+/** People on a card of another board of the project: the ids readWall must not ask about (round fifteen, entries 18 and 21). */
+function elsewhereIds(boardId) {
+  if (!lastHeld?.project) return [];
+  return Object.keys(castElsewhere(lastHeld.project, lastHeld.boards, boardId ?? lastHeld.project.activeBoardId));
+}
+/** Everything a reading of one board needs to know about the rest of the project (R51, R58), from the last project read. */
+function readOptions(boardId, state = null) {
+  if (!lastHeld?.project) return { elsewhere: [] };
+  const id = boardId ?? lastHeld.project.activeBoardId;
+  const boards = state ? { ...lastHeld.boards, [id]: state } : lastHeld.boards;
+  return { elsewhere: elsewhereIds(id), laterBoards: laterBoards(lastHeld.project, boards), paidBy: landingsOn(lastHeld.project, boards, id).paid };
+}
+/** A card's number as the reading prints it: the lock's when locked, else its place in story order. */
+function sceneLabel(state, noteId) {
+  const numbers = state.lock ? sceneNumbers(storyOrder(state), state.lock) : null;
+  const numbered = numbers?.get?.(noteId);
+  if (numbered) return numbered;
+  const index = storyOrder(state).findIndex((note) => note.id === noteId);
+  return index >= 0 ? String(index + 1) : "?";
+}
+/** "Ep 1, sc 4": a scene on another board, named by the board's place in the project and the scene's in its story (R58). */
+function episodeLabel(project, boards, boardId, noteId) {
+  const index = project.boards.findIndex((meta) => meta.id === boardId);
+  const state = isBoardState(boards[boardId]) ? normalizeState(boards[boardId]) : null;
+  return `Ep ${index + 1}${state && noteId ? `, sc ${sceneLabel(state, noteId)}` : ""}`;
+}
+async function readProjectUncached() {
   const viaAccount = await throughAccount(accountReadProject);
   if (viaAccount) return viaAccount;
   const base = await findBridge();
@@ -738,8 +774,13 @@ async function writeBoardRaw(next, rev, base, boardId = null) {
       log("bridge write failed, falling back to file:", error);
     }
   }
-  writeFileBoard(next, rev + 1, boardId);
-  syncProjectFileBoard(boardId, next);
+  // A board file from before the project file has no id of its own; once a
+  // project file exists it is that project's open board, and it has to say so,
+  // or nothing written here reaches the project's copy and open_board later
+  // brings back a stale one (found by round fifteen's cross-board move).
+  const id = boardId ?? readFileProject()?.project.activeBoardId ?? null;
+  writeFileBoard(next, rev + 1, id);
+  syncProjectFileBoard(id, next);
   return false;
 }
 
@@ -765,9 +806,11 @@ const sinceRead = [];
 /** What the last write did to the wall's questions and runtime, said once on that write's tail (round fourteen, entries 18, 19, 42). */
 let lastChange = null;
 const findingKey = (finding) => `${finding.kind}|${finding.ids.join(",")}|${finding.text}`;
-function noteChange(before, after) {
-  const was = readWall(before);
-  const now = readWall(after);
+function noteChange(before, after, boardId = null) {
+  // The same reading read_wall gives: a person cast on another board is not
+  // asked about, so a write's tail never names a question the reading does not.
+  const was = readWall(before, readOptions(boardId, before));
+  const now = readWall(after, readOptions(boardId, after));
   const wasKeys = new Set(was.findings.map(findingKey));
   const nowKeys = new Set(now.findings.map(findingKey));
   lastChange = {
@@ -845,7 +888,7 @@ async function commit(command) {
   const live = await writeBoard(next, rev, base, boardId, "exact");
   trail.push({ before: state, after: canon(next), what: describeCommand(command) });
   sinceRead.push(describeCommand(command));
-  noteChange(state, next);
+  noteChange(state, next, boardId);
   if (trail.length > TRAIL_CAP) trail.shift();
   undone.length = 0;
   return { state: next, changed, result, live };
@@ -877,7 +920,7 @@ async function commitAll(what, build) {
   const live = await writeBoard(current, rev, base, boardId, "exact");
   trail.push({ before: state, after: canon(current), what });
   sinceRead.push(what);
-  noteChange(state, current);
+  noteChange(state, current, boardId);
   if (trail.length > TRAIL_CAP) trail.shift();
   undone.length = 0;
   return { state: current, changed: true, value, live };
@@ -932,7 +975,7 @@ const CHECK_WORDS = {
   unlinked: "no card without an arrow",
   duplicate: "no two headlines alike",
   sequence: "no group too long for one sequence (act groups are not asked)",
-  uncast: "nobody in the cast on no card",
+  uncast: "nobody in the cast on no card of the project",
   absent: "nobody gone for a third of the story",
   backwards: "no payoff before its setup",
   unpaid: "no fold without a payoff",
@@ -942,20 +985,36 @@ const SAMPLE_NOTE = "sample: this is the wall PlotCoder starts with (Maya, Tom,
 
 // --- Reporting -------------------------------------------------------------
 
+/** What kinds of number a runtime folds together: measured from text, set by the writer, or the default page (round fifteen, entry 39). */
+function runtimeKinds(state) {
+  const measured = state.notes.filter((note) => isMeasured(note)).length;
+  const sized = state.notes.filter((note) => !isMeasured(note) && note.lengthEighths !== null).length;
+  const unsized = state.notes.length - measured - sized;
+  if (!state.notes.length) return "";
+  return `; of its ${state.notes.length} cards, ${measured} measured from written text, ${sized} sized by the writer, ${unsized} unsized and read as a page each`;
+}
+
 function summarize(state) {
   const nameOf = new Map(state.characters.map((character) => [character.id, character.name]));
+  // What lands here from the other boards' folds (R58), from the last project read.
+  const paidByHere = lastHeld?.project ? landingsOn(lastHeld.project, { ...lastHeld.boards, [lastHeld.project.activeBoardId]: state }, lastHeld.project.activeBoardId).paid : [];
   const notes = storyOrder(state)
     .map((note) => {
       const cast = note.characterIds.map((id) => nameOf.get(id) ?? id);
       const who = cast.length ? `, cast: ${cast.join(", ")}` : "";
-      const plant = note.plants ? (note.payoffBoardId ? ", plants → pays off later" : ", plants") : "";
+      // The board it pays off on, named here as read_wall names it (round fifteen, entry 44).
+      const laterName = note.payoffBoardId ? (lastHeld?.project?.boards?.find((meta) => meta.id === note.payoffBoardId)?.name ?? note.payoffBoardId) : null;
+      const laterAt = note.payoffBoardId && note.payoffNoteId && lastHeld?.project ? ` at ${episodeLabel(lastHeld.project, lastHeld.boards, note.payoffBoardId, note.payoffNoteId)} "${lastHeld.boards[note.payoffBoardId]?.notes?.find((item) => item.id === note.payoffNoteId)?.headline ?? note.payoffNoteId}"` : "";
+      const plant = note.plants ? (note.payoffBoardId ? `, plants → pays off later on "${laterName}"${laterAt || ", no scene there claimed yet"}` : ", plants") : "";
+      // The receiving end (R58): what this card pays off from another board, composed from the project.
+      const pays = paidByHere.filter((item) => item.id === note.id).map((item) => `, pays off "${item.fromHeadline}" from "${item.fromBoardName}" (${episodeLabel(lastHeld.project, lastHeld.boards, item.fromBoardId, item.fromNoteId)})`).join("");
       const snap = state.revision?.snapshot?.[note.id];
       const revised = snap && (snap.headline !== note.headline || snap.change !== note.change || (snap.text ?? "") !== (note.text ?? "") || (snap.location ?? "") !== (note.location ?? "")) ? `, changed in ${state.revision.color}` : "";
       const place = note.location ? `, at: ${note.location}` : "";
       const when = note.when ? `, when: ${note.when}` : "";
       const count = formatPages(noteEighths(note));
       const pages = isMeasured(note) ? `${count} ${count === "1" ? "page" : "pages"}, written` : note.lengthEighths === null ? "about a page, unsized" : `${count} ${count === "1" ? "page" : "pages"}`;
-      return `  - ${note.id} [${note.rank ?? "scene"}, ${pages}${who}${place}${when}${plant}${revised}] — "${note.headline}" (${note.color}) at ${Math.round(note.x)},${Math.round(note.y)}`;
+      return `  - ${note.id} [${note.rank ?? "scene"}, ${pages}${who}${place}${when}${plant}${pays}${revised}] — "${note.headline}" (${note.color}) at ${Math.round(note.x)},${Math.round(note.y)}`;
     })
     .join("\n");
   const cast = state.characters
@@ -1023,8 +1082,8 @@ function summarize(state) {
     `left, for now: ${leftCount ? `${leftCount} question(s) the writer left; read_wall lists them` : "none"}`,
     `beats: ${beats}, scenes: ${scenes}`,
     state.targetEighths === DEFAULT_TARGET_EIGHTHS
-      ? `runtime: about ${formatPages(runtime)} pages (an estimate from the cards; a page runs about a minute); no target set — set_target for a pilot (60) or a half-hour (30); against the feature default of 120 it would be ${formatPages(-over)} under`
-      : `runtime: about ${formatPages(runtime)} pages of a ${formatPages(state.targetEighths)}-page target — ${over > 0 ? `${formatPages(over)} over` : over < 0 ? `${formatPages(-over)} under` : "on it"} (an estimate from the cards; a page runs about a minute)`,
+      ? `runtime: about ${formatPages(runtime)} pages (an estimate from the cards; a page runs about a minute); no target set — set_target for a pilot (60) or a half-hour (30); against the feature default of 120 it would be ${formatPages(-over)} under${runtimeKinds(state)}`
+      : `runtime: about ${formatPages(runtime)} pages of a ${formatPages(state.targetEighths)}-page target — ${over > 0 ? `${formatPages(over)} over` : over < 0 ? `${formatPages(-over)} under` : "on it"} (an estimate from the cards; a page runs about a minute)${runtimeKinds(state)}`,
     `notes: ${state.notes.length}, groups: ${state.groups.length}, arrows: ${state.arrows.length}, cast: ${state.characters.length}`,
     "cards (in story order — the follows arrows over the rows; each with its id):",
     notes || "  (no cards)",
@@ -1370,7 +1429,11 @@ server.registerTool(
       .map((group) => (group.dissolved ? ` Its group "${group.title}" dissolved: a frame needs two cards.` : ` Left its group "${group.title}", which keeps ${group.remaining} card${group.remaining === 1 ? "" : "s"}.`))
       .join("");
     const joined = result.joined ? ` The chain is joined behind it: "${result.joined.fromHeadline}" → "${result.joined.toHeadline}" (follows).` : "";
-    return ok(`Deleted "${result.headline}"${where(live)}.${arrows}${joined}${groups}`, result);
+    // The fold and where it paid off went with the card (round fifteen, entry 17).
+    const fold = result.plants
+      ? ` Its folded corner went with it${result.payoffBoardId ? ` — it paid off later, on "${(await readProject()).project.boards.find((meta) => meta.id === result.payoffBoardId)?.name ?? result.payoffBoardId}"` : ""}; nothing on the wall plants that now.`
+      : "";
+    return ok(`Deleted "${result.headline}"${where(live)}.${arrows}${joined}${groups}${fold}`, result);
   },
 );
 
@@ -1389,8 +1452,10 @@ server.registerTool(
     const { project: projectForRead } = await readProject();
     const readBoardMeta = boardById(projectForRead, readBoardId ?? projectForRead.activeBoardId);
     const { boards: boardsForRead } = await readProject();
-    const elsewhereForRead = castElsewhere(projectForRead, boardsForRead, readBoardId ?? projectForRead.activeBoardId);
-    const reading = readWall(state, { elsewhere: Object.keys(elsewhereForRead) });
+    const readId = readBoardId ?? projectForRead.activeBoardId;
+    const boardsNow = { ...boardsForRead, [readId]: state };
+    const elsewhereForRead = castElsewhere(projectForRead, boardsForRead, readId);
+    const reading = readWall(state, { elsewhere: Object.keys(elsewhereForRead), laterBoards: laterBoards(projectForRead, boardsNow), paidBy: landingsOn(projectForRead, boardsNow, readId).paid });
     lastReading = { findings: reading.findings };
     sinceRead.length = 0;
     const runs = describeRuns(reading, state).map((line, index) => {
@@ -1431,7 +1496,8 @@ server.registerTool(
       ...(reading.setups.length
         ? describeSetups(reading, state).map((line) => `  - ${line}`)
         : ["  (no arrow is marked as a setup)"]),
-      ...reading.later.map((item) => `  - "${state.notes.find((note) => note.id === item.id)?.headline ?? item.id}" is folded and pays off later, on "${boardById(projectForRead, item.boardId)?.name ?? item.boardId}"`),
+      ...reading.later.map((item) => `  - "${state.notes.find((note) => note.id === item.id)?.headline ?? item.id}" is folded and pays off later, on "${boardById(projectForRead, item.boardId)?.name ?? item.boardId}"${item.noteId ? `, at ${episodeLabel(projectForRead, boardsNow, item.boardId, item.noteId)} "${boardsNow[item.boardId]?.notes?.find((note) => note.id === item.noteId)?.headline ?? item.noteId}"` : " — no scene there claims it yet"}`),
+      ...reading.paidBy.map((item) => `  - "${state.notes.find((note) => note.id === item.id)?.headline ?? item.id}" pays off "${item.fromHeadline}" from "${item.fromBoardName}" (${episodeLabel(projectForRead, boardsNow, item.fromBoardId, item.fromNoteId)}), one board earlier`),
       "questions the wall raises:",
       ...(reading.findings.length
         ? reading.findings.map((finding) => `  - [${finding.kind}] ${finding.text}${finding.ids.length ? ` (ids: ${finding.ids.join(", ")})` : ""}`)
@@ -1481,8 +1547,9 @@ server.registerTool(
   async (args) => {
     const wanted = args.questions?.length ? args.questions : args.kind ? [{ kind: args.kind, ids: args.ids, why: args.why }] : [];
     if (!wanted.length) return ok("Say which question: its kind as read_wall names it (and ids when that kind is asked more than once), or a list under questions.");
-    const { state } = await readBoard();
-    const reading = readWall(state);
+    const { state, boardId: leaveBoardId } = await readBoard();
+    const readOptions_ = readOptions(leaveBoardId, state);
+    const reading = readWall(state, readOptions_);
     const replies = [];
     const toLeave = [];
     for (const want of wanted) {
@@ -1522,7 +1589,7 @@ server.registerTool(
       after = out.state;
       for (const item of toLeave) replies.push(`Left, for now: [${item.finding.kind}] ${item.finding.text}${item.why ? ` — "${item.why}"` : ""}`);
     }
-    const still = readWall(after).findings;
+    const still = readWall(after, readOptions(leaveBoardId, after)).findings;
     const tail = toLeave.length
       ? `${where(live)} ${once("leave-rule", "The wall keeps the writer's word and asks a left question again on its own when it would read differently; ask_again brings one back now. ")}The wall still asks ${still.length === 0 ? "nothing" : `${still.length}: ${still.map((finding) => `[${finding.kind}] ${finding.text}`).join(" ")}`}.`
       : "";
@@ -1542,7 +1609,8 @@ server.registerTool(
     const held = (state.left ?? []).filter((item) => item.kind === args.kind && (!args.ids || sameList(item.ids, args.ids)));
     if (held.length === 0) return ok(`Nothing of kind "${args.kind}"${args.ids ? ` about ids ${args.ids.join(", ")}` : ""} is left. read_wall lists what is, under "left, for now".`);
     const { result, live } = await commit({ type: "ask_again", kind: args.kind, ids: args.ids });
-    const reading = readWall((await readBoard()).state);
+    const again = await readBoard();
+    const reading = readWall(again.state, readOptions(again.boardId, again.state));
     const back = reading.findings.filter((finding) => held.some((item) => item.kind === finding.kind && sameList(item.ids, finding.ids)));
     return ok(
       `Asked again${where(live)}: ${held.length} question${held.length === 1 ? "" : "s"} of kind "${args.kind}" ${held.length === 1 ? "is" : "are"} no longer left${back.length ? ` — the wall asks ${back.length === 1 ? "it" : `${back.length} of them`} now: ${back.map((finding) => finding.text).join(" ")}` : " — and the wall no longer asks it; the question had already changed"}.`,
@@ -1551,15 +1619,117 @@ server.registerTool(
   },
 );
 
+/**
+ * A scene moves to another board of the project (round fifteen, entry 16: a
+ * writer's "the shim should open episode two" had no tool, and the way round
+ * was a delete and a recreate by hand). Two frames, one per board: the card
+ * leaves the open board with everything a delete takes, and lands on the
+ * target with its own record — cast, place, when, rank, length, text, fold —
+ * wired after or before a card there, or at the head of that board's story.
+ */
+async function moveAcrossBoards(args, target, open, held) {
+  if (args.after && args.before) return ok("Say where: after one card's id, or before one, not both.");
+  const card = open.state.notes.find((note) => note.id === args.id);
+  if (!card) return ok(`No card with id ${args.id}. Call list_board.`);
+  const fromMeta = boardById(held.project, open.boardId ?? held.project.activeBoardId);
+  const targetState = isBoardState(held.boards[target.id]) ? normalizeState(held.boards[target.id]) : emptyState();
+  const anchorId = args.after ?? args.before;
+  const anchor = anchorId ? targetState.notes.find((note) => note.id === anchorId) : null;
+  if (anchorId && !anchor) return ok(`No card with id ${anchorId} on "${target.name}". open_board there and list_board for its ids, or leave after and before out to land at the head of its story.`);
+  // Leave: one frame on the board it is on.
+  let taken = null;
+  await commitAll(`move_scene "${card.headline}" to "${target.name}" (leave)`, (step) => {
+    taken = step({ type: "delete_note", id: card.id }).result;
+  });
+  // Open the board it is going to, everywhere.
+  const now = await readProject();
+  await openBoardEverywhere(now.project, now.boards, now.rev, now.base, target.id);
+  // Land: one frame there.
+  const isFollows = (arrow) => arrow.kind !== "setup";
+  let landedId = card.id;
+  let joinedGroup = null;
+  let headOf = null;
+  let forgotLater = false;
+  const { state: final, live } = await commitAll(`move_scene "${card.headline}" to "${target.name}" (land)`, (step, current) => {
+    const here = current();
+    landedId = here.notes.some((note) => note.id === card.id) ? newId() : card.id;
+    step({
+      type: "create_note",
+      id: landedId,
+      headline: card.headline,
+      change: card.change,
+      color: card.color,
+      rank: card.rank,
+      lengthEighths: card.lengthEighths,
+      characterIds: card.characterIds,
+      plants: card.plants,
+      location: card.location,
+      when: card.when,
+      text: card.text,
+      ...nextPlace(here),
+    });
+    if (card.plants && card.payoffBoardId && card.payoffBoardId !== target.id) step({ type: "set_payoff_board", ids: [landedId], boardId: card.payoffBoardId });
+    if (card.plants && card.payoffBoardId === target.id) forgotLater = true;
+    if (anchor) {
+      const mid = current();
+      if (args.after) {
+        for (const arrow of mid.arrows.filter((item) => isFollows(item) && item.from === anchor.id)) {
+          step({ type: "delete_arrow", id: arrow.id });
+          step({ type: "create_arrow", from: landedId, to: arrow.to, kind: "follows" });
+        }
+        step({ type: "create_arrow", from: anchor.id, to: landedId, kind: "follows" });
+      } else {
+        for (const arrow of mid.arrows.filter((item) => isFollows(item) && item.to === anchor.id)) {
+          step({ type: "delete_arrow", id: arrow.id });
+          step({ type: "create_arrow", from: arrow.from, to: landedId, kind: "follows" });
+        }
+        step({ type: "create_arrow", from: landedId, to: anchor.id, kind: "follows" });
+      }
+      const anchorGroup = current().groups.find((group) => group.noteIds.includes(anchor.id));
+      if (anchorGroup) {
+        step({ type: "add_to_group", id: anchorGroup.id, noteIds: [landedId] });
+        joinedGroup = anchorGroup.title || "an untitled group";
+      }
+    } else {
+      const head = storyOrder(here)[0];
+      if (head && here.arrows.some(isFollows)) {
+        step({ type: "create_arrow", from: landedId, to: head.id, kind: "follows" });
+        headOf = head.headline;
+      }
+    }
+    step({ type: "apply_poses", poses: organizePoses(current(), {}) });
+  });
+  const order = storyOrder(final);
+  const arrows = taken?.arrows?.length
+    ? ` Left behind on "${fromMeta.name}": ${taken.arrows.map((arrow) => `"${arrow.fromHeadline}" → "${arrow.toHeadline}" (${arrow.kind}${arrow.kind === "setup" && arrow.to === card.id ? "; that fold is unpaid again" : ""})`).join(", ")}${taken.joined ? `; the chain is joined behind it, "${taken.joined.fromHeadline}" → "${taken.joined.toHeadline}"` : ""}.`
+    : ` No arrow touched it on "${fromMeta.name}".`;
+  const groups = (taken?.groups ?? []).map((group) => (group.dissolved ? ` Its group "${group.title}" there dissolved: a frame needs two cards.` : ` It left its group "${group.title}" there, which keeps ${group.remaining} card${group.remaining === 1 ? "" : "s"}.`)).join("");
+  const landed = anchor
+    ? `${args.after ? "after" : "before"} "${anchor.headline}"${joinedGroup ? `, in "${joinedGroup}"` : ""}`
+    : headOf ? `at the head of the story, before "${headOf}"` : "as the only card wired to nothing yet";
+  const fold = card.plants ? (forgotLater ? " It paid off later on this board, so that mark is forgotten: draw the setup arrow here." : " Its folded corner came with it; a setup arrow does not cross boards, so draw the payoff here if it is here.") : "";
+  return ok(
+    `Moved "${card.headline}" from "${fromMeta.name}" to "${target.name}", with its cast, place, when, rank, length${card.text ? ", text" : ""} and colour; it is card ${landedId} there${where(live)}.${arrows}${groups} It landed ${landed}, and the wall was tidied.${fold} Story order on "${target.name}" now: ${order.map((note, index) => `${index + 1}. ${note.headline}`).join(", ")}. "${target.name}" is the open board now. Undo is per board: undo here takes back the landing; open_board "${fromMeta.name}" and undo takes back the leaving.`,
+    { id: landedId, board: target.id, order: order.map((note) => note.id) },
+  );
+}
+
 server.registerTool(
   "move_scene",
   {
     title: "Move a scene in the story",
     description:
-      "Move a card to another place in the story order — after one card, or before one — by rewiring its follows arrows and tidying the wall along them, as one step that undo takes back whole. The story order is the follows arrows: the card leaves its place (what pointed at it now points at what it pointed at) and lands between the target and what followed it. A person does this by dragging in the outline. Needs a wall with follows arrows; on a wall without any, create_arrow the sequence first, or move_note by position.",
-    inputSchema: { id: z.string(), after: z.string().optional(), before: z.string().optional() },
+      "Move a card to another place in the story order — after one card, or before one — by rewiring its follows arrows and tidying the wall along them, as one step that undo takes back whole. The story order is the follows arrows: the card leaves its place (what pointed at it now points at what it pointed at) and lands between the target and what followed it. A person does this by dragging in the outline. Needs a wall with follows arrows; on a wall without any, create_arrow the sequence first, or move_note by position. To another board of the project: pass board (name, id or number from list_boards) and, optionally, after or before a card there; with neither the card lands at the head of that board's story. Across boards the card keeps its cast, place, when, rank, length, text and fold; its arrows stay behind, and that board is then the open one. Undo is per board: one step there, one on the board it left.",
+    inputSchema: { id: z.string(), after: z.string().optional(), before: z.string().optional(), board: z.union([z.string().min(1), z.number()]).optional() },
   },
   async (args) => {
+    if (args.board !== undefined) {
+      const held = await readProject();
+      const target = findBoard(held.project, String(args.board));
+      if (!target) return ok(`No board matches "${args.board}". Call list_boards for the real ones.`);
+      const open = await readBoard();
+      if (target.id !== (open.boardId ?? held.project.activeBoardId)) return moveAcrossBoards(args, target, open, held);
+    }
     if (!args.after === !args.before) return ok("Say where: after one card's id, or before one, not both.");
     const { state } = await readBoard();
     const find = (id) => state.notes.find((note) => note.id === id);
@@ -1711,7 +1881,8 @@ server.registerTool(
     const lines = [
       `the writer's own: ${own.length}`,
       ...own.map((structure) => `  - ${structure.id} — "${structure.name}" (${structure.beats.length} beats: ${structure.beats.map((beat) => `${beat.name} at ${Math.round(beat.at * 100)}%`).join(", ")})`),
-      `built in: ${TEMPLATES.length} — ${TEMPLATES.map((template) => `${template.id} "${template.name}" (${template.beats.length} beats)`).join(", ")}; each beat's name, prompt and place in the story are in the JSON`,
+      `built in: ${TEMPLATES.length}`,
+      ...TEMPLATES.map((template) => `  - ${template.id} — "${template.name}" (${template.beats.length} beats: ${template.beats.map((beat) => `${beat.name} at ${Math.round(beat.at * 100)}%`).join(", ")})`),
       "compare_structure sets one of these beside this wall's beats, page by page, and lays nothing",
     ];
     return ok(lines.join("\n"), { builtIn: TEMPLATES.map((template) => ({ id: template.id, name: template.name, beats: template.beats })), own });
@@ -1737,12 +1908,15 @@ server.registerTool(
     if (!chosen) return ok(`No structure called "${args.structure}". list_structures names the built-in five and the writer's own.`);
     const comparison = compareStructure(state, chosen.beats);
     const beats = state.notes.filter((note) => note.rank === "beat").length;
+    const allMeasured = state.notes.length > 0 && state.notes.every((note) => isMeasured(note));
+    const short = state.targetEighths > 0 && boardEighths(state) * 2 < state.targetEighths;
     const lines = [
-      `"${chosen.name}" beside this wall's ${beats} beat${beats === 1 ? "" : "s"}, of ${formatPages(state.targetEighths)} pages (the story so far runs to p. ${comparison.soFar}); a match is the nearest of the wall's beats within ${MATCH_PAGES} pages, one to one and in order:`,
+      `"${chosen.name}" beside this wall's ${beats} beat${beats === 1 ? "" : "s"}, of ${formatPages(state.targetEighths)} pages (the story so far runs to p. ${comparison.soFar}${allMeasured ? ", measured" : ", an estimate: unsized cards read as a page each"}); a match is the nearest of the wall's beats within ${MATCH_PAGES} pages, one to one and in order:`,
       ...describeComparison(comparison).map((line) => `  - ${line}`),
       comparison.unmatched.length
         ? `beats of the wall no beat of the structure answers: ${comparison.unmatched.map((beat) => `"${beat.headline}" (p. ${beat.page})`).join(", ")}`
         : "every beat of the wall answers one of the structure's",
+      ...(short ? [`the wall runs to less than half its target, so its beats sit early and the ${MATCH_PAGES}-page window pairs them with the structure's first beats by arithmetic; the pairing says more once the cards are sized or written, and whether a turn is missing is the writer's call, not this reading's`] : []),
       beats === 0 ? "No card on this board is marked as a beat (set_rank), so there is nothing to compare; apply_template lays the structure's beats to fill." : "Nothing moved and nothing was made: this is a reading. apply_template lays the beats as cards when the writer wants them.",
     ];
     return ok(lines.join("\n"), { structure: { id: chosen.id, name: chosen.name }, ...comparison });
@@ -1870,7 +2044,7 @@ server.registerTool(
     }
     const printed = sceneLineCount(args.text);
     return ok(
-      `Wrote "${result.headline}": ${printed} line(s) as they print (headings, blank lines and wrapped dialogue counted), measured at ${formatPages(noteEighths(result))} of a 55-line page, rounded to the nearest eighth and never below one${where(live)}.${revisionMark(state, result.id)}${once("heading-from-place", " The heading comes from the card's place and when, so the text starts with the action.")} While the text stands the card is measured, not estimated; the estimate underneath is untouched.`,
+      `Wrote "${result.headline}": ${printed} line(s) as they print (headings, blank lines and wrapped dialogue counted), measured at ${formatPages(noteEighths(result))} of a 55-line page, rounded to the nearest eighth and never below one eighth${where(live)}.${revisionMark(state, result.id)}${once("heading-from-place", " The heading comes from the card's place and when, so the text starts with the action.")} While the text stands the wall reads the measure, not the estimate${result.lengthEighths !== null ? ` (the writer's ${formatPages(result.lengthEighths)} pages)` : ""}; the estimate is kept for when the text goes, and set_length changes it.`,
       { ...result, eighths: noteEighths(result), measured: true, printedLines: printed },
     );
   },
@@ -2026,7 +2200,7 @@ server.registerTool(
   {
     title: "Export as Final Draft",
     description:
-      "The open board as a Final Draft .fdx: a heading per card with its scene number by wall order, the scene's text as script paragraphs (action, character, parenthetical, dialogue, dual dialogue, transition) or the change line as action after the mark [Unwritten] when unwritten, and a title page for the project (a one-board film is its project). Pass a path to write the file; otherwise the XML comes back.",
+      "The open board as a Final Draft .fdx: a heading per card with its scene number by wall order, the scene's text as script paragraphs (action, character, parenthetical, dialogue, dual dialogue, transition) or the change line as action after the mark [Unwritten] when unwritten, and a title page: the project's name, and for a series the episode line (Episode 2 of 6 · its name). One board per file; a series is one file per episode. Pass a path to write the file; otherwise the XML comes back with the file's name in a comment on its second line.",
     inputSchema: { path: z.string().optional() },
   },
   async (args) => {
@@ -2035,12 +2209,14 @@ server.registerTool(
     const board = project.boards.find((item) => item.id === project.activeBoardId);
     const titles = scriptTitles(project, board);
     const xml = toFdx(state, { ...titles, draftDate: new Date().toISOString() });
+    // The file's name, so an agent writing it by hand has one (round fifteen, entry 34).
+    const filename = `${titles.title}${titles.episode ? ` - ${board?.name ?? ""}` : ""}`.replace(/[\\/:*?"<>|]+/g, " ").replace(/\s+/g, " ").trim() + ".fdx";
     if (args.path) {
       fs.mkdirSync(path.dirname(path.resolve(args.path)), { recursive: true });
       fs.writeFileSync(args.path, xml);
-      return ok(`Wrote a Final Draft file with ${state.notes.length} scene(s), titled "${titles.title}", to ${args.path}.`);
+      return ok(`Wrote a Final Draft file with ${state.notes.length} scene(s), titled "${titles.title}"${titles.episode ? ` (${titles.episode})` : ""}, to ${args.path}.`);
     }
-    return ok(xml);
+    return ok(xml.replace(/^(<\?xml[^>]*\?>\n)/, `$1<!-- Save as: ${filename.replace(/--/g, "- -")} -->\n`));
   },
 );
 
@@ -2397,11 +2573,12 @@ server.registerTool(
   {
     title: "Fold the corner",
     description:
-      `Fold the corner of cards — mark them as planting something — or unfold them. ${wordSentence("corner")} The setup arrow is create_arrow with kind 'setup'. A fold that pays off in a later episode: pass later, another board of the project by name, id or number — a board that exists; new_board makes one — and the wall stops asking where it comes back, listing the card under the reading's 'later' instead of 'payoffs'; later '' forgets it. Folding never moves a card.`,
+      `Fold the corner of cards — mark them as planting something — or unfold them. ${wordSentence("corner")} The setup arrow is create_arrow with kind 'setup'. A fold that pays off in a later episode: pass later, another board of the project by name, id or number — a board that exists; new_board makes one — and, once you know it, at: the scene on that board that pays it off, by id or headline. A board alone is a promise: the reading lists the card under 'later' and, once that board holds cards, asks which scene until one claims it; with at, both boards' readings name the payoff and the paying-off card says so. later '' forgets the board; at '' keeps the board and forgets the scene. set_payoff makes the same claim from the other board. Folding never moves a card.`,
     inputSchema: {
       ids: z.array(z.string()).min(1),
       plants: z.boolean(),
       later: z.string().optional(),
+      at: z.string().optional(),
     },
   },
   async (args) => {
@@ -2409,15 +2586,29 @@ server.registerTool(
     // The kernel cannot check the board exists; this door can, before anything lands.
     let target = null;
     let forgetting = false;
-    if (args.plants && args.later !== undefined) {
-      const { project } = await readProject();
-      const { boardId: current } = await readBoard();
-      if (args.later.trim() === "") {
+    let atNote = null;
+    let atClearing = false;
+    if (args.plants && (args.later !== undefined || args.at !== undefined)) {
+      const { project, boards } = await readProject();
+      const { state: here, boardId: current } = await readBoard();
+      if (args.later !== undefined && args.later.trim() === "") {
         forgetting = true;
       } else {
-        target = findBoard(project, args.later);
+        // `at` alone means the board the fold already names.
+        const key = args.later ?? here.notes.find((note) => args.ids.includes(note.id) && note.payoffBoardId)?.payoffBoardId;
+        if (!key) return ok("Say which board with later before at: a scene belongs to a board.");
+        target = findBoard(project, String(key));
         if (!target) return ok(`No board called "${args.later}" yet. A fold pays off later on a board of the project: new_board "${args.later}" makes it (empty), open_board back to this one, then set_plant again with later.`);
         if (target.id === (current ?? project.activeBoardId)) return ok(`"${target.name}" is this board. A payoff on the same board is a setup arrow: create_arrow from the fold to the scene, kind 'setup'.`);
+        if (args.at !== undefined) {
+          if (args.at.trim() === "") atClearing = true;
+          else {
+            const there = isBoardState(boards[target.id]) ? normalizeState(boards[target.id]) : emptyState();
+            const wanted = args.at.trim().toLowerCase();
+            atNote = there.notes.find((note) => note.id === args.at.trim()) ?? there.notes.find((note) => note.headline.trim().toLowerCase() === wanted) ?? null;
+            if (!atNote) return ok(`No card on "${target.name}" with id or headline "${args.at}". open_board there and list_board for its cards; or leave at out and the fold stays a promise on that board.`);
+          }
+        }
       }
     }
     // The fold and the board it pays off on land as one change: one ⌘Z on the wall.
@@ -2431,10 +2622,14 @@ server.registerTool(
           laterLine = " The board it paid off on is forgotten; read_wall asks again until a setup arrow or a board pays it off.";
         }
       } else if (target) {
-        const named = step({ type: "set_payoff_board", ids: args.ids, boardId: target.id });
+        const named = step({ type: "set_payoff_board", ids: args.ids, boardId: target.id, noteId: atNote?.id ?? null });
         if (named.changed) result = named.result;
         const here = current().notes.filter((note) => args.ids.includes(note.id));
-        laterLine = ` ${here.length} card(s) pay off later, on "${target.name}": read_wall stops asking where they come back, and the card says so.`;
+        laterLine = atNote
+          ? ` ${here.length} card(s) pay off at "${atNote.headline}" on "${target.name}": both boards' readings name it, and that card says what it pays off.`
+          : atClearing
+            ? ` ${here.length} card(s) pay off later, on "${target.name}", and no scene there is claimed: read_wall asks which once that board holds cards.`
+            : ` ${here.length} card(s) pay off later, on "${target.name}": the card says so, and read_wall asks which scene once that board holds cards — set_plant with at, or set_payoff from that board, names it.`;
       }
       return { result, laterLine };
     });
@@ -2452,6 +2647,52 @@ server.registerTool(
 
 // --- Characters -------------------------------------------------------
 
+// The receiving end of a series plant (R58), claimed from the board it lands
+// on: the same record set_plant's `at` writes, on the fold's own card, so one
+// claim has one owner. Two board switches around one frame on the fold's
+// board, which is where undo takes it back.
+server.registerTool(
+  "set_payoff",
+  {
+    title: "Pay off a fold from another board",
+    description:
+      "Say that a card on this board pays off a fold of another board of the project: id (the card here), from (that board, by name, id or number), and fold (the folded card there, by id or headline). The claim is written on the fold's card — the twin of set_plant with later and at — so both boards' readings name it and the card here says what it pays off. fold '' takes back every claim of that board on this card. The wall's other board is opened for the write and this one reopened after; undo on that board takes the claim back.",
+    inputSchema: { id: z.string(), from: z.union([z.string().min(1), z.number()]), fold: z.string() },
+  },
+  async (args) => {
+    const { project, boards } = await readProject();
+    const { state: here, boardId } = await readBoard();
+    const hereId = boardId ?? project.activeBoardId;
+    const card = here.notes.find((note) => note.id === args.id);
+    if (!card) return ok(`No card with id ${args.id} on this board. Call list_board.`);
+    const source = findBoard(project, String(args.from));
+    if (!source) return ok(`No board matches "${args.from}". Call list_boards for the real ones.`);
+    if (source.id === hereId) return ok(`"${source.name}" is this board. A payoff on the same board is a setup arrow: create_arrow from the fold to this card, kind 'setup'.`);
+    const there = isBoardState(boards[source.id]) ? normalizeState(boards[source.id]) : emptyState();
+    const clearing = args.fold.trim() === "";
+    const wanted = args.fold.trim().toLowerCase();
+    const folds = clearing
+      ? there.notes.filter((note) => note.plants && note.payoffBoardId === hereId && note.payoffNoteId === card.id)
+      : [there.notes.find((note) => note.id === args.fold.trim()) ?? there.notes.find((note) => note.headline.trim().toLowerCase() === wanted)].filter(Boolean);
+    if (!folds.length) return ok(clearing ? `No fold of "${source.name}" claims "${card.headline}".` : `No card on "${source.name}" with id or headline "${args.fold}". open_board there and list_board for its cards.`);
+    if (!clearing && !folds[0].plants) return ok(`"${folds[0].headline}" on "${source.name}" is not folded: nothing to pay off. set_plant it there first, with later "${boardById(project, hereId)?.name ?? hereId}".`);
+    const held = await readProject();
+    await openBoardEverywhere(held.project, held.boards, held.rev, held.base, source.id);
+    const { changed } = await commitAll(`set_payoff "${card.headline}"`, (step) => {
+      for (const fold of folds) step({ type: "set_payoff_board", ids: [fold.id], boardId: clearing ? hereId : hereId, noteId: clearing ? null : card.id });
+    });
+    const back = await readProject();
+    const { live } = await openBoardEverywhere(back.project, back.boards, back.rev, back.base, hereId);
+    if (!changed) return ok(`No change: ${clearing ? "nothing was claimed" : `"${folds[0].headline}" already pays off at "${card.headline}"`}.`);
+    return ok(
+      clearing
+        ? `"${card.headline}" no longer pays off ${folds.map((fold) => `"${fold.headline}"`).join(", ")} from "${source.name}"; ${folds.length === 1 ? "that fold is" : "those folds are"} a promise on this board again${where(live)}. This board is open again; undo on "${source.name}" takes it back.`
+        : `"${card.headline}" pays off "${folds[0].headline}" from "${source.name}" (${episodeLabel(project, { ...boards, [hereId]: here }, source.id, folds[0].id)})${where(live)}. The fold's card there says "paid off in ${episodeLabel(project, { ...boards, [hereId]: here }, hereId, card.id)}", this card says what it pays off, and both readings list it. This board is open again; undo on "${source.name}" takes the claim back.`,
+      { fold: folds.map((fold) => fold.id), board: source.id, card: card.id },
+    );
+  },
+);
+
 server.registerTool(
   "add_character",
   {
@@ -2467,7 +2708,7 @@ server.registerTool(
         ? ok(`Already in the cast as "${result.name}" (${result.id}). Use that id.`, result)
         : ok("No character added: the name was empty.");
     }
-    return ok(`Added "${result.name}" to the project's cast${where(live)}; every board of the project casts from it.`, result);
+    return ok(`Added "${result.name}" (id ${result.id}) to the project's cast${where(live)}; every board of the project casts from it.`, result);
   },
 );
 
@@ -2505,22 +2746,37 @@ server.registerTool(
   {
     title: "Read a person's page",
     description:
-      "Read one person's page back, by id or by name: the five lines — looks, voice, wants, needs, notes — as they stand, and which cards the person is on. list_board says only which lines are written; this says what they say.",
+      "Read one person's page back, by id or by name: the five lines — looks, voice, wants, needs, notes — as they stand, and every card the person is on across every board of the project, in story order, each with its place, when and rank. The cast is the project's (one record, one page), so this reads all of it; list_board says only which lines are written.",
     inputSchema: { id: z.string().optional(), name: z.string().optional() },
   },
   async (args) => {
     const key = (args.id ?? args.name ?? "").trim();
     if (!key) return ok("Say who: the person's id or name from list_board.");
-    const { state } = await readBoard();
+    const { state, boardId } = await readBoard();
+    const { project, boards } = await readProject();
     const wanted = key.toLowerCase();
     const person = state.characters.find((item) => item.id === key) ?? state.characters.find((item) => item.name.trim().toLowerCase() === wanted);
     if (!person) return ok(`Nobody called "${key}" in the cast. Call list_board for the cast, or add_character.`);
-    const on = storyOrder(state).filter((note) => note.characterIds.includes(person.id));
+    // The person's part is the project's, not one board's (R51; round fifteen,
+    // entries 22 and 23): every board, in the project's order, the open one read live.
+    const openId = boardId ?? project.activeBoardId;
+    const parts = project.boards.map((meta) => {
+      const held = meta.id === openId ? state : isBoardState(boards[meta.id]) ? normalizeState(boards[meta.id]) : emptyState();
+      const on = storyOrder(held).filter((note) => (note.characterIds ?? []).includes(person.id));
+      return { meta, on };
+    });
+    const total = parts.reduce((sum, part) => sum + part.on.length, 0);
+    const where_ = (note) => [note.location ? `at ${note.location}` : "", note.when ? note.when : "", note.rank === "beat" ? "beat" : ""].filter(Boolean).join(" · ");
     const lines = [
-      `${person.name} (${person.id}) — on ${on.length} card${on.length === 1 ? "" : "s"}${on.length ? `, in story order: ${on.map((note) => `"${note.headline}"`).join(", ")}` : ""}`,
+      `${person.name} (${person.id}) — on ${total} card${total === 1 ? "" : "s"} across ${project.boards.length} board${project.boards.length === 1 ? "" : "s"} of the project`,
       ...CHARACTER_FIELDS.map((field) => `  ${field}: ${(person[field] ?? "").trim() || "(empty)"}`),
+      ...parts.map((part) =>
+        part.on.length
+          ? `  "${part.meta.name}", ${part.on.length} card${part.on.length === 1 ? "" : "s"} in story order: ${part.on.map((note, index) => `${index + 1}. "${note.headline}"${where_(note) ? ` (${where_(note)})` : ""}`).join("; ")}`
+          : `  "${part.meta.name}": on no card`,
+      ),
     ];
-    return ok(lines.join("\n"), { ...person, cards: on.map((note) => note.id) });
+    return ok(lines.join("\n"), { ...person, cards: parts.flatMap((part) => part.on.map((note) => note.id)), boards: parts.map((part) => ({ id: part.meta.id, name: part.meta.name, cards: part.on.map((note) => note.id) })) });
   },
 );
 
@@ -2706,7 +2962,7 @@ server.registerTool(
           : "No group made: a group needs at least two cards.",
       );
     }
-    return ok(`Grouped ${result.noteIds.length} cards as "${result.title}"${where(live)}.`, result);
+    return ok(`Grouped ${result.noteIds.length} cards as "${result.title}" (group id ${result.id})${where(live)}.`, result);
   },
 );
 
@@ -2876,6 +3132,16 @@ server.registerTool(
         `premise: ${project.premise ? `"${project.premise}"` : "(not set)"}`,
         `boards: ${project.boards.length}`,
         describeBoards(project, boards, changedAt),
+        // The project's length as one line, so a series is not arithmetic by hand (round fifteen, entry 38).
+        ...(project.boards.length > 1
+          ? (() => {
+              const states = project.boards.map((meta) => (isBoardState(boards[meta.id]) ? normalizeState(boards[meta.id]) : null)).filter(Boolean);
+              const pages = states.reduce((sum, state) => sum + boardEighths(state), 0);
+              const target = states.reduce((sum, state) => sum + state.targetEighths, 0);
+              const cards = states.reduce((sum, state) => sum + state.notes.length, 0);
+              return [`the whole project: ${cards} cards, about ${formatPages(pages)} of ${formatPages(target)} pages across ${states.length} boards (each board's runtime is an estimate unless every scene is written)`];
+            })()
+          : []),
       ].join("\n"),
       project,
     );
@@ -2911,7 +3177,11 @@ server.registerTool(
     const next = renameProject(project, args.name);
     if (next === project) return ok("Project name unchanged.");
     await writeProject(next, boards, rev, base);
-    return ok(`Project renamed to "${next.name}"${where(live)}.`, next);
+    // The line at the head of every reply names the project it works; it must
+    // follow the rename (round fifteen, entry 40).
+    if (accountDoor) workingProject(next.id, next.name);
+    const several = (next.boards ?? []).length > 1;
+    return ok(`Project renamed to "${next.name}"${where(live)}. It shows at the head of every reply, in list_boards and read_wall, and as the title of every script out${several ? `, where each board follows it as an episode line (Episode 1 of ${next.boards.length} · ${next.boards[0].name})` : ""}. The boards keep their names.`, next);
   },
 );
 

package/src/board/agents.js

@@ -42,7 +42,7 @@ export const AGENTS = {
       text: "Skip this when the account is the wall. Without an account, a wall is a folder: any folder, empty is fine — choose one that will outlive your session, never a scratch one. The app run from that folder shows the wall, and the server writes it there (PLOTCODER_ROOT, or the folder it is run from). A fresh folder holds the sample; new_board for the writer's wall, then rename_project. No app running? export_fountain is the wall in order, as text.",
     },
   ],
-  firstNote: "Make these four before anything else; none depends on another, so any order is fine. list_words and list_workflows are the app's and read no project; read_wall and list_reminders are about the wall you will work, so after open_project, open_board, new_project or empty_account, make those two again. Every reply's first line names the project it read and how many the account holds; list_projects lists them. On an account with no project yet, read_wall has nothing to read and says so, and list_reminders gives the house principles every project starts with; new_project (name, pages, and board for the first board's name), then read_wall and list_reminders again. No server in front of you, and no shell to take the shell door? Nothing gets you in from inside the session: say so, and ask the person to wire the server and start a new session.",
+  firstNote: "Make these four before anything else; none depends on another, so any order is fine. list_words and list_workflows are the app's and read no project; read_wall and list_reminders are about the wall you will work, so after open_project or open_board make those two again, and after new_project read the wall once it holds cards. An emptied account has nothing to read: go straight to new_project. Every reply's first line names the project it read and how many the account holds; list_projects lists them. On an account with no project yet, read_wall has nothing to read and says so, and list_reminders gives the house principles every project starts with; new_project (name, pages, and board for the first board's name). The reading holds the beats and the runs; the ids of every card, the cast and the places are list_board's, so make that your fifth call before you touch anything. No server in front of you, and no shell to take the shell door? Nothing gets you in from inside the session: say so, and ask the person to wire the server and start a new session.",
   first: [
     { tool: "list_words", why: "the room's words, the app's meaning." },
     { tool: "read_wall", why: "the reading: the beats, the runs, the setups, and what the wall asks. The records — every card, the cast, the places, the rows — are list_board's. A fresh folder holds a sample wall (Maya, Tom, the letter) and the reading says so only when it is the sample; it is not the writer's." },
@@ -64,16 +64,19 @@ export const AGENTS = {
 
 /** The on-ramp as one text: the file at /llms.txt, and what an agent reads. */
 export function agentsAsText() {
-  const lines = ["# PlotCoder — for agents", "", AGENTS.lead, "", `The guide: ${AGENTS.guide}. Read it once, before your first call if you can; it is the whole and this page is its first page, and where the two differ, the guide wins. Then Call these first, below. The doors between are for wiring a server in; skip them when the tools are already in front of you.`, "", "## Doors"];
-  for (const door of AGENTS.doors) {
-    lines.push(`- ${door.name}: ${door.text}`);
-    if (door.code) lines.push("", "```", door.code, "```", "");
-  }
-  lines.push("## Call these first");
+  // The calls and the rules first, the doors after: an agent with the tools in
+  // front of it reads two pages of wiring it was told to skip before it reached
+  // the first call (round fifteen, entry 1).
+  const lines = ["# PlotCoder — for agents", "", AGENTS.lead, "", `The guide: ${AGENTS.guide}. Read it once, before your first call if you can; it is the whole and this page is its first page, and where the two differ, the guide wins. Then Call these first, below. The doors at the end are for wiring a server in; skip them when the tools are already in front of you.`, "", "## Call these first"];
   AGENTS.first.forEach((item, index) => lines.push(`${index + 1}. ${item.tool} — ${item.why}`));
   lines.push("", AGENTS.firstNote);
   lines.push("", "## Rules");
   for (const rule of AGENTS.rules) lines.push(`- ${rule}`);
-  lines.push("", "## For the person", AGENTS.person, "", "## The guide", AGENTS.guide, "");
+  lines.push("", "## Doors");
+  for (const door of AGENTS.doors) {
+    lines.push(`- ${door.name}: ${door.text}`);
+    if (door.code) lines.push("", "```", door.code, "```", "");
+  }
+  lines.push("## For the person", AGENTS.person, "", "## The guide", AGENTS.guide, "");
   return lines.join("\n");
 }

package/src/board/fdx.d.ts

@@ -5,7 +5,7 @@ import type { FountainScene } from "./fountain";
 
 export declare function toFdx(
   state: BoardState,
-  options?: { title?: string; project?: string; author?: string; draftDate?: string },
+  options?: { title?: string; episode?: string; author?: string; draftDate?: string },
 ): string;
 
 export type SetAside = {

package/src/board/fdx.js

@@ -88,10 +88,11 @@ export function toFdx(state, options = {}) {
 
   const title = [];
   if (options.title) title.push(paragraph("General", options.title, ' Alignment="Center"'));
-  if (options.project && options.project !== options.title) title.push(paragraph("General", `An episode of ${options.project}`, ' Alignment="Center"'));
+  if (options.episode) title.push(paragraph("General", options.episode, ' Alignment="Center"'));
   if (options.author) title.push(paragraph("General", `Written by ${options.author}`, ' Alignment="Center"'));
   if (options.draftDate) title.push(paragraph("General", options.draftDate.slice(0, 10)));
-  title.push(paragraph("General", state.lock ? `Scene numbers locked ${String(state.lock.at).slice(0, 10)}.` : "Scene numbers follow the wall's order and are not locked."));
+  // A lock is a fact about the document; that there is none is the app's business, not the title page's (round fifteen, entry 36).
+  if (state.lock) title.push(paragraph("General", `Scene numbers locked ${String(state.lock.at).slice(0, 10)}.`));
   if (state.revision) title.push(paragraph("General", `${revisionLine(state)}; changed paragraphs are marked.`));
   // The revision set Final Draft shows its marks from (round fourteen, entry 45).
   const revisions = state.revision

package/src/board/fountain.d.ts

@@ -12,6 +12,7 @@ export declare function unmark(text: string | null | undefined): { text: string;
 
 export declare function titlePage(titles: {
   title?: string;
+  episode?: string;
   credit?: string;
   author?: string;
   draftDate?: string;
@@ -22,7 +23,7 @@ export type FountainOptions = {
   /** The board's name. */
   title?: string;
   /** The project's name, when the board is one of several. */
-  project?: string;
+  episode?: string;
   premise?: string;
   author?: string;
   /** ISO date string; only the date is printed. */

package/src/board/fountain.js

@@ -61,9 +61,10 @@ export function unmark(text) {
 }
 
 /** The title page block. `titles` is what the writer would put above the script. */
-export function titlePage({ title, credit, author, draftDate, notes }) {
+export function titlePage({ title, episode, credit, author, draftDate, notes }) {
   const lines = [];
   if (title) lines.push(`Title: ${title}`);
+  if (episode) lines.push(`Episode: ${episode}`);
   if (credit) lines.push(`Credit: ${credit}`);
   if (author) lines.push(`Author: ${author}`);
   if (draftDate) lines.push(`Draft date: ${draftDate}`);
@@ -97,7 +98,7 @@ export function toFountain(state, options = {}) {
 
   const head = titlePage({
     title: options.title || "Untitled",
-    credit: options.project && options.project !== options.title ? `An episode of ${options.project}` : undefined,
+    episode: options.episode,
     author: options.author,
     draftDate: options.draftDate ? options.draftDate.slice(0, 10) : undefined,
     notes,

package/src/board/markdown.d.ts

@@ -2,7 +2,7 @@ import type { Line } from "./paginate";
 import type { BoardState } from "./reducer";
 
 /** What a document carries above the script: the board's name, the project's when it has several boards, the premise. */
-export type TakeOptions = { title?: string; project?: string; premise?: string };
+export type TakeOptions = { title?: string; episode?: string; premise?: string };
 
 /** The wall as Markdown (R54): title, premise, logline, beats as headings, a heading per scene, the text or the change line. */
 export declare function toMarkdown(state: BoardState, options?: TakeOptions): string;

package/src/board/markdown.js

@@ -28,7 +28,7 @@ function upper(text) {
 
 function documentTitle(options) {
   const title = options.title || "Untitled";
-  return options.project && options.project !== title ? `${options.project} · ${title}` : title;
+  return options.episode ? `${title} · ${options.episode}` : title;
 }
 
 /** A scene's text as Markdown paragraphs: action as it is, a speech as its cue in bold with the lines hard-broken under it. */
@@ -177,8 +177,8 @@ export function toPlainText(state, options = {}) {
   );
   const title = options.title || "Untitled";
   const out = [];
-  if (options.project && options.project !== title) {
-    out.push(centred(upper(options.project)), "", centred(title));
+  if (options.episode) {
+    out.push(centred(upper(title)), "", centred(options.episode));
   } else {
     out.push(centred(upper(title)));
   }

package/src/board/project.d.ts

@@ -68,7 +68,7 @@ export declare function renameProject(project: ProjectRecord, name: string, now?
 export declare function setPremise(project: ProjectRecord, premise: string, now?: string): ProjectRecord;
 export declare function boardById(project: ProjectRecord, id: string): BoardMeta | null;
 /** What a script going out is called: a named project is the title, its board beside it only when the project has several. */
-export declare function scriptTitles(project: ProjectRecord, board: BoardMeta | null | undefined): { title: string; project?: string };
+export declare function scriptTitles(project: ProjectRecord, board: BoardMeta | null | undefined): { title: string; episode?: string };
 export declare function findBoard(project: ProjectRecord, key: string): BoardMeta | null;
 export declare function reidentifyProject(
   project: ProjectRecord,
@@ -85,6 +85,11 @@ export declare function liftCast(
 ): { project: ProjectRecord; boards: Record<string, BoardState>; changed: boolean };
 export type CastElsewhere = Record<string, Array<{ board: string; boardId: string; cards: number }>>;
 export declare function castElsewhere(project: ProjectRecord, boards: Record<string, BoardState>, activeBoardId: string): CastElsewhere;
+
+/** A fold on another board that lands here (R58): the fold's board, card and colour, and the paying-off card here (null while waiting). */
+export type Landing = { id: string | null; fromBoardId: string; fromBoardName: string; fromNoteId: string; fromHeadline: string; fromColor: string };
+export declare function landingsOn(project: ProjectRecord, boards: Record<string, BoardState>, boardId: string): { paid: Array<Landing & { id: string }>; waiting: Landing[] };
+export declare function laterBoards(project: ProjectRecord, boards: Record<string, BoardState>): Record<string, { name: string; cards: number; noteIds: string[] }>;
 export declare function mergeRoster(
   project: ProjectRecord,
   state: BoardState,

package/src/board/project.js

@@ -220,6 +220,42 @@ export function castElsewhere(project, boards, activeBoardId) {
   return map;
 }
 
+/**
+ * What lands on a board from the folds of the project's other boards (R58):
+ * `paid` — folds that name a scene here, keyed for the paying-off card;
+ * `waiting` — folds that name this board and no scene on it yet (or a scene
+ * that is gone). The receiving board carries no record of its own; this is
+ * composed from the project, the way castElsewhere composes the cast.
+ */
+export function landingsOn(project, boards, boardId) {
+  const here = boards[boardId];
+  const hereIds = new Set((here?.notes ?? []).map((note) => note.id));
+  const paid = [];
+  const waiting = [];
+  for (const meta of project.boards) {
+    if (meta.id === boardId) continue;
+    const state = boards[meta.id];
+    if (!state) continue;
+    for (const note of state.notes) {
+      if (!note.plants || note.payoffBoardId !== boardId) continue;
+      const landing = { fromBoardId: meta.id, fromBoardName: meta.name, fromNoteId: note.id, fromHeadline: note.headline, fromColor: note.color };
+      if (note.payoffNoteId && hereIds.has(note.payoffNoteId)) paid.push({ ...landing, id: note.payoffNoteId });
+      else waiting.push({ ...landing, id: note.payoffNoteId ?? null });
+    }
+  }
+  return { paid, waiting };
+}
+
+/** Every board's name, card count and card ids, for the reading to judge a fold's promise by (R58). */
+export function laterBoards(project, boards) {
+  const map = {};
+  for (const meta of project.boards) {
+    const state = boards[meta.id];
+    map[meta.id] = { name: meta.name, cards: state?.notes?.length ?? 0, noteIds: (state?.notes ?? []).map((note) => note.id) };
+  }
+  return map;
+}
+
 function touch(project, patch, now) {
   return { ...project, ...patch, updatedAt: now };
 }
@@ -300,7 +336,15 @@ export function scriptTitles(project, board) {
   const boardName = (board?.name ?? "").trim() || "Untitled";
   const named = typeof project?.name === "string" && project.name.trim() && project.name !== DEFAULT_PROJECT_NAME;
   if (!named) return { title: boardName };
-  if ((project.boards ?? []).length > 1) return { title: boardName, project: project.name };
+  const boards = project.boards ?? [];
+  if (boards.length > 1) {
+    // A series: the project is the title and the board is the episode line,
+    // numbered in the project's order, so one file says which episode it is
+    // (round fifteen, entries 32 and 37).
+    const index = boards.findIndex((item) => item.id === board?.id);
+    const number = index >= 0 ? `Episode ${index + 1} of ${boards.length}` : "An episode";
+    return { title: project.name, episode: `${number} · ${boardName}` };
+  }
   return { title: project.name };
 }
 

package/src/board/readWall.d.ts

@@ -61,8 +61,10 @@ export type WallReading = {
   /** Every planted card: the scene that pays it off (first setup arrow, by wall order), or null while unpaid. */
   /** For each folded card, the cards its setup arrows land on, in wall order; empty when unpaid. */
   payoffs: Record<string, string[]>;
-  /** Folded cards that pay off on another board of the project (R50): the card and the board. */
-  later: { id: string; boardId: string }[];
+  /** Folded cards that pay off on another board of the project (R50): the card, the board, and the scene there that claims it (R58) or null while the board is a promise. */
+  later: { id: string; boardId: string; noteId: string | null }[];
+  /** Cards here that pay off a fold of another board (R58), composed by the door from the project. */
+  paidBy: Array<{ id: string; fromBoardId: string; fromBoardName: string; fromNoteId: string; fromHeadline: string; fromColor: string }>;
   /** The questions the wall asks now. A left one (R53) is not here while its words hold. */
   findings: Finding[];
   /** Questions the writer has left, for now: the same question, with when it was left. */
@@ -78,6 +80,10 @@ export declare function readWall(
   options?: {
     /** Cast ids on a card of another board of the project (R51): not asked about as uncast here. */
     elsewhere?: string[];
+    /** Every board of the project by id (R58): a fold's promise is asked about once that board holds cards and no scene claims it. */
+    laterBoards?: Record<string, { name: string; cards: number; noteIds: string[] }>;
+    /** Folds of other boards that land on cards here (R58). */
+    paidBy?: Array<{ id: string; fromBoardId: string; fromBoardName: string; fromNoteId: string; fromHeadline: string; fromColor: string }>;
   },
 ): WallReading;
 export declare function describeRuns(reading: WallReading, state: BoardState): string[];

package/src/board/readWall.js

@@ -165,6 +165,11 @@ export function readWall(state, options = {}) {
   // People on a card of another board of the project (R51) are cast, and
   // are not asked about here.
   const elsewhere = new Set(Array.isArray(options.elsewhere) ? options.elsewhere : []);
+  // The project's other boards, for a fold that pays off later (R58): a board
+  // that holds cards and no claimed scene is a promise the wall asks about.
+  const boardsHeld = options.laterBoards && typeof options.laterBoards === "object" ? options.laterBoards : null;
+  // Folds of other boards that land on a card here (R58), composed by the door.
+  const paidBy = Array.isArray(options.paidBy) ? options.paidBy : [];
   const order = storyOrder(state);
   const beats = order.filter((note) => note.rank === "beat");
 
@@ -230,9 +235,14 @@ export function readWall(state, options = {}) {
     const note = byId.get(id);
     return note && (note.lengthEighths !== null || (note.text ?? "").trim());
   }));
-  if (between.length >= 2 && claimed) {
-    const typical = median(between.map((run) => run.eighths));
-    const longest = between.reduce((top, run) => (run.eighths > top.eighths ? run : top));
+  // The typical run is the median of the runs that hold a card: an empty run
+  // is a question of its own ("empty"), and counting it here made a small
+  // wall's one ordinary scene read as a sag against a median of an eighth
+  // (round fifteen, entry 10).
+  const filled = between.filter((run) => run.ids.length > 0);
+  if (filled.length >= 2 && claimed) {
+    const typical = median(filled.map((run) => run.eighths));
+    const longest = filled.reduce((top, run) => (run.eighths > top.eighths ? run : top));
     if (typical > 0 && longest.eighths > SAG_RATIO * typical) {
       findings.push({
         kind: "sag",
@@ -375,7 +385,13 @@ export function readWall(state, options = {}) {
   }
   // A fold that pays off on another board (R50) is not unpaid: it is listed
   // under `later`, and the door that knows the project names the board.
-  const later = order.filter((note) => note.plants && note.payoffBoardId).map((note) => ({ id: note.id, boardId: note.payoffBoardId }));
+  const later = order
+    .filter((note) => note.plants && note.payoffBoardId)
+    .map((note) => {
+      const held = boardsHeld?.[note.payoffBoardId];
+      const claimed = Boolean(note.payoffNoteId && (!held || held.noteIds.includes(note.payoffNoteId)));
+      return { id: note.id, boardId: note.payoffBoardId, noteId: claimed ? note.payoffNoteId : null };
+    });
   for (const note of order) {
     if (note.plants && !paysOff.has(note.id) && !note.payoffBoardId) {
       findings.push({
@@ -385,6 +401,20 @@ export function readWall(state, options = {}) {
       });
     }
   }
+  // A board's name is a promise; a scene is the payoff (R58). Once the board
+  // has cards, the wall asks which one, until a scene there claims the fold.
+  for (const item of later) {
+    const held = boardsHeld?.[item.boardId];
+    if (!held || held.cards === 0 || item.noteId) continue;
+    const note = byId.get(item.id);
+    findings.push({
+      kind: "unpaid",
+      ids: [item.id],
+      text: `${quote(note)} pays off later, on "${held.name}", but no scene there claims it yet. Which one?`,
+    });
+  }
+  const hereIds = new Set(order.map((note) => note.id));
+  const paidHere = paidBy.filter((item) => hereIds.has(item.id));
 
   // The cast (R29): someone who vanishes for a stretch, or never appears.
   const total = boardEighths(state);
@@ -458,6 +488,7 @@ export function readWall(state, options = {}) {
     setups,
     payoffs,
     later,
+    paidBy: paidHere,
     findings: asked,
     left,
   };

package/src/board/reducer.d.ts

@@ -81,6 +81,8 @@ export type BoardNote = {
   plants: boolean;
   /** When folded: the id of another board of the project where it pays off (R50), or null. */
   payoffBoardId: string | null;
+  /** The scene on that board that pays it off (R58), or null while the board is only a promise. */
+  payoffNoteId: string | null;
   /** Where the scene happens (R37): a phrase in the writer's words; empty until set. */
   location: string;
   /** When the scene happens, as the writer says it — "night", "day four, dawn" — printed after the place on the heading (R55). Empty when unsaid. */
@@ -184,7 +186,7 @@ export type Command =
   | ({ type: "update_character"; id: string } & Partial<Record<CharacterField, string>>)
   | { type: "set_cast"; ids: string[]; characterIds: string[] }
   | { type: "set_plant"; ids: string[]; plants: boolean }
-  | { type: "set_payoff_board"; ids: string[]; boardId: string | null }
+  | { type: "set_payoff_board"; ids: string[]; boardId: string | null; noteId?: string | null }
   | { type: "set_location"; ids: string[]; location: string }
   | { type: "set_when"; ids: string[]; when: string }
   | { type: "apply_template"; template: string; beats?: Array<{ name: string; prompt: string; at: number }> }

package/src/board/reducer.js

@@ -249,8 +249,10 @@ export function seedState(now = nowIso()) {
     text: "",
     plants: false,
     // A fold that pays off on another board — a later episode — names it here;
-    // null claims nothing (R50).
+    // null claims nothing (R50). The scene there that pays it off, once one
+    // does (R58); null while the board is a promise.
     payoffBoardId: null,
+    payoffNoteId: null,
     createdAt: now,
     updatedAt: now,
   });
@@ -346,6 +348,8 @@ export function normalizeState(value) {
     const plants = note?.plants === true;
     // Cards written before R50 pay off on their own board or not at all.
     const payoffBoardId = plants && typeof note?.payoffBoardId === "string" && note.payoffBoardId ? note.payoffBoardId : null;
+    // Cards written before R58 name a board and no scene on it.
+    const payoffNoteId = payoffBoardId && typeof note?.payoffNoteId === "string" && note.payoffNoteId ? note.payoffNoteId : null;
     // Cards written before R37 have no place; a scene is nowhere until it is.
     const location = typeof note?.location === "string" ? note.location : "";
     // Cards written before R55 have no when; a scene is at no time until it is.
@@ -360,6 +364,7 @@ export function normalizeState(value) {
       sameIds(note.characterIds, characterIds) &&
       note.plants === plants &&
       note.payoffBoardId === payoffBoardId &&
+      note.payoffNoteId === payoffNoteId &&
       note.location === location &&
       note.when === when &&
       note.text === text
@@ -367,7 +372,7 @@ export function normalizeState(value) {
       return note;
     }
     patched = true;
-    return { ...note, rank, lengthEighths, characterIds, plants, payoffBoardId, location, when, text };
+    return { ...note, rank, lengthEighths, characterIds, plants, payoffBoardId, payoffNoteId, location, when, text };
   });
 
   // Boards written before the production half (Roadmap 2, item 8) have no
@@ -453,6 +458,7 @@ export function applyCommand(state, command, now = nowIso()) {
         characterIds: knownCast(command.characterIds, state.characters ?? []),
         plants: command.plants === true,
         payoffBoardId: null,
+        payoffNoteId: null,
         location: cleanPlace(command.location),
         when: cleanWhen(command.when),
         text: typeof command.text === "string" ? command.text : "",
@@ -620,6 +626,11 @@ export function applyCommand(state, command, now = nowIso()) {
         result: {
           id: command.id,
           headline: gone.headline,
+          // The fold and where it paid off go with the card too; a door that
+          // says what went should say these (round fifteen, entry 17).
+          plants: gone.plants === true,
+          payoffBoardId: gone.payoffBoardId ?? null,
+          payoffNoteId: gone.payoffNoteId ?? null,
           arrows: taken.map((arrow) => ({ ...arrow, fromHeadline: headlineOf(arrow.from), toHeadline: headlineOf(arrow.to) })),
           joined: joined ? { ...joined, fromHeadline: headlineOf(joined.from), toHeadline: headlineOf(joined.to) } : null,
           groups: left,
@@ -905,6 +916,7 @@ export function applyCommand(state, command, now = nowIso()) {
         characterIds: [],
         plants: false,
         payoffBoardId: null,
+        payoffNoteId: null,
         location: "",
         when: "",
         text: "",
@@ -1036,8 +1048,9 @@ export function applyCommand(state, command, now = nowIso()) {
         if (!ids.has(note.id)) return note;
         // Unfolding forgets where it paid off; a claim that no longer stands.
         const payoffBoardId = plants ? note.payoffBoardId : null;
-        if (note.plants === plants && note.payoffBoardId === payoffBoardId) return note;
-        const next = bump(note, { plants, payoffBoardId }, now);
+        const payoffNoteId = plants ? (note.payoffNoteId ?? null) : null;
+        if (note.plants === plants && note.payoffBoardId === payoffBoardId && note.payoffNoteId === payoffNoteId) return note;
+        const next = bump(note, { plants, payoffBoardId, payoffNoteId }, now);
         touched.push(next);
         return next;
       });
@@ -1049,14 +1062,18 @@ export function applyCommand(state, command, now = nowIso()) {
     // stops asking where it comes back, and the reading says where. The
     // kernel cannot check the board exists; the door that knows the project
     // does. Null takes the claim back.
+    // With noteId, the scene on that board that pays it off (R58): the
+    // receiving end, kept here on the fold so one claim has one owner. A
+    // board alone is a promise; a note is the payoff.
     case "set_payoff_board": {
       const ids = new Set(command.ids);
       if (ids.size === 0) return { state, changed: false };
       const payoffBoardId = typeof command.boardId === "string" && command.boardId ? command.boardId : null;
+      const payoffNoteId = payoffBoardId && typeof command.noteId === "string" && command.noteId ? command.noteId : null;
       const touched = [];
       const notes = state.notes.map((note) => {
-        if (!ids.has(note.id) || !note.plants || note.payoffBoardId === payoffBoardId) return note;
-        const next = bump(note, { payoffBoardId }, now);
+        if (!ids.has(note.id) || !note.plants || (note.payoffBoardId === payoffBoardId && (note.payoffNoteId ?? null) === payoffNoteId)) return note;
+        const next = bump(note, { payoffBoardId, payoffNoteId }, now);
         touched.push(next);
         return next;
       });