plotcoder-board 0.1.5 → 0.1.7

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. Seventy-one tools: reading (`list_board`, `read_wall`, `read_pages`, `read_character`, `page_count`, `list_words`, `list_workflows`, `segment_brief`); the card, cast, place, group and arrow verbs, `set_logline`, `set_target`, `set_rank`, `set_plant`, `write_scene`, `organize`, `apply_template` with `list_structures`, `save_structure`, `remove_structure`; `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; 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. Seventy-two tools: reading (`list_board`, `read_wall`, `read_pages`, `read_character`, `page_count`, `list_words`, `list_workflows`, `segment_brief`); the card, cast, place, group and arrow verbs, `set_logline`, `set_target`, `set_rank`, `set_plant`, `write_scene`, `move_scene`, `organize`, `apply_template` with `list_structures`, `save_structure`, `remove_structure`; `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; 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.

package/package.json

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

package/scripts/plotcoder-mcp-server.mjs

@@ -697,11 +697,30 @@ function describeCommand(command) {
       return `create_note "${command.headline ?? ""}"`;
     case "recolor_notes":
       return "recolor_note";
+    case "apply_poses":
+      return "organize";
     default:
       return command.type;
   }
 }
 
+/**
+ * A board as one canonical string, so "has the board changed since my call?"
+ * compares boards and not the JSON a store happened to write: the account
+ * stores JSON in its own key order, and a byte comparison refused every undo
+ * but the first (round ten, finding 29).
+ */
+function canon(state) {
+  const sorted = (value) => {
+    if (Array.isArray(value)) return value.map(sorted);
+    if (value && typeof value === "object") {
+      return Object.fromEntries(Object.keys(value).sort().map((key) => [key, sorted(value[key])]));
+    }
+    return value;
+  };
+  return JSON.stringify(sorted(normalizeState(state)));
+}
+
 async function commit(command) {
   const { state, rev, base, boardId } = await readBoard();
   const { state: next, changed, result } = applyCommand(state, command);
@@ -711,7 +730,7 @@ async function commit(command) {
   if (!changed) return { state: next, changed, result, live: base !== null };
 
   const live = await writeBoard(next, rev, base, boardId);
-  trail.push({ before: state, after: JSON.stringify(next), what: describeCommand(command) });
+  trail.push({ before: state, after: canon(next), what: describeCommand(command) });
   if (trail.length > TRAIL_CAP) trail.shift();
   undone.length = 0;
   return { state: next, changed, result, live };
@@ -790,6 +809,15 @@ function summarize(state) {
       return `  - ${character.id} — "${character.name}" on ${on} card${on === 1 ? "" : "s"}${brief}`;
     })
     .join("\n");
+  const placeCounts = new Map();
+  for (const note of state.notes) {
+    const phrase = (note.location ?? "").trim();
+    if (phrase) placeCounts.set(phrase, (placeCounts.get(phrase) ?? 0) + 1);
+  }
+  const places = [...placeCounts.entries()]
+    .sort((a, b) => a[0].localeCompare(b[0]))
+    .map(([phrase, count]) => `  - "${phrase}" on ${count} card${count === 1 ? "" : "s"}`)
+    .join("\n");
   const { beats, scenes } = countRanks(state);
   const headline = (id) =>
     state.notes.find((note) => note.id === id)?.headline ?? "(missing card)";
@@ -823,10 +851,14 @@ function summarize(state) {
     `logline: ${state.logline ? `"${state.logline}"` : "(not set)"}`,
     ...production,
     `beats: ${beats}, scenes: ${scenes}`,
-    `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)${state.targetEighths === DEFAULT_TARGET_EIGHTHS ? " — the target is the feature default, nobody's choice yet; set_target for a pilot or a half-hour" : ""}`,
+    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)`,
     `notes: ${state.notes.length}, groups: ${state.groups.length}, arrows: ${state.arrows.length}, cast: ${state.characters.length}`,
     "cast:",
     cast || "  (no one yet — add_character to start the roster)",
+    "places (each distinct phrase is one place; near-matches sit side by side):",
+    places || "  (no card says where it happens yet)",
     "cards:",
     notes || "  (no cards)",
     "groups:",
@@ -996,7 +1028,7 @@ server.registerTool(
     },
   },
   async (args) => {
-    const { result, live } = await commit({
+    let { result, live } = await commit({
       type: "create_note",
       headline: args.headline,
       change: args.change,
@@ -1027,7 +1059,12 @@ server.registerTool(
         }
         if (person) ids.push(person.id);
       }
-      if (ids.length) await commit({ type: "set_cast", ids: [result.id], characterIds: ids });
+      if (ids.length) {
+        const cast = await commit({ type: "set_cast", ids: [result.id], characterIds: ids });
+        // The card as it is now, cast and all, so the reply's JSON agrees with its prose.
+        const after = cast.state.notes.find((note) => note.id === result.id);
+        if (after) result = after;
+      }
       castLine = ` Cast: ${args.characters.map((name) => name.trim()).join(", ")}${added.length ? ` (added to the roster: ${added.join(", ")})` : ""}.`;
     }
     const landed = [
@@ -1139,6 +1176,20 @@ server.registerTool(
     const lines = [
       `PlotCoder wall (${door(live, base)})`,
       `logline: ${state.logline ? `"${state.logline}"` : "(none yet)"}`,
+      state.targetEighths === DEFAULT_TARGET_EIGHTHS
+        ? `runtime: about ${formatPages(boardEighths(state))} pages; no target set (set_target)`
+        : `runtime: about ${formatPages(boardEighths(state))} pages of a ${formatPages(state.targetEighths)}-page target — ${boardEighths(state) > state.targetEighths ? `${formatPages(boardEighths(state) - state.targetEighths)} over` : boardEighths(state) < state.targetEighths ? `${formatPages(state.targetEighths - boardEighths(state))} under` : "on it"}`,
+      `groups: ${
+        state.groups.length
+          ? state.groups
+              .map((group) => {
+                const members = state.notes.filter((note) => group.noteIds.includes(note.id));
+                const act = /^act\b/i.test((group.title ?? "").trim());
+                return `"${group.title || "(untitled)"}" — ${members.length} card(s), about ${formatPages(members.reduce((sum, note) => sum + noteEighths(note), 0))} pages${act ? ", read as an act (never asked whether it is one sequence)" : ", read as a sequence"}`;
+              })
+              .join("; ")
+          : "(none)"
+      }`,
       `pages: ${written === 0 ? "all estimates — no scene is written yet, so every card is the writer's guess" : written === state.notes.length ? "measured — every scene is written" : `estimates — ${written} of ${state.notes.length} cards are written, the rest are guesses`}`,
       `beats in wall order: ${
         reading.beats.length
@@ -1162,12 +1213,81 @@ server.registerTool(
   },
 );
 
+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() },
+  },
+  async (args) => {
+    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);
+    const card = find(args.id);
+    const target = find(args.after ?? args.before);
+    if (!card) return ok(`No card with id ${args.id}. Call list_board.`);
+    if (!target) return ok(`No card with id ${args.after ?? args.before}. Call list_board.`);
+    if (card.id === target.id) return ok("A card cannot be moved next to itself.");
+    const isFollows = (arrow) => arrow.kind !== "setup";
+    if (!state.arrows.some(isFollows)) {
+      return ok("The wall has no follows arrows, so there is no story order to move within: create_arrow the sequence first, or move_note the card by position.");
+    }
+    const trailBefore = trail.length;
+    let removed = 0;
+    let drawn = 0;
+    let live = false;
+    const step = async (command) => {
+      const done = await commit(command);
+      if (done.changed) {
+        live = done.live;
+        if (command.type === "delete_arrow") removed += 1;
+        if (command.type === "create_arrow") drawn += 1;
+      }
+      return done;
+    };
+    // Leave: what pointed at the card points at what the card pointed at.
+    const ins = state.arrows.filter((arrow) => isFollows(arrow) && arrow.to === card.id);
+    const outs = state.arrows.filter((arrow) => isFollows(arrow) && arrow.from === card.id);
+    for (const arrow of [...ins, ...outs]) await step({ type: "delete_arrow", id: arrow.id });
+    for (const before of ins) for (const after of outs) if (before.from !== after.to) await step({ type: "create_arrow", from: before.from, to: after.to, kind: "follows" });
+    // Land: between the target and what followed it (or what led to it).
+    const { state: mid } = await readBoard();
+    if (args.after) {
+      for (const arrow of mid.arrows.filter((item) => isFollows(item) && item.from === target.id && item.to !== card.id)) {
+        await step({ type: "delete_arrow", id: arrow.id });
+        await step({ type: "create_arrow", from: card.id, to: arrow.to, kind: "follows" });
+      }
+      await step({ type: "create_arrow", from: target.id, to: card.id, kind: "follows" });
+    } else {
+      for (const arrow of mid.arrows.filter((item) => isFollows(item) && item.to === target.id && item.from !== card.id)) {
+        await step({ type: "delete_arrow", id: arrow.id });
+        await step({ type: "create_arrow", from: arrow.from, to: card.id, kind: "follows" });
+      }
+      await step({ type: "create_arrow", from: card.id, to: target.id, kind: "follows" });
+    }
+    const { state: linked } = await readBoard();
+    const tidied = await step({ type: "apply_poses", poses: organizePoses(linked, {}) });
+    const final = tidied.state;
+    // One step for undo: the whole move, not its dozen arrows.
+    trail.splice(trailBefore);
+    trail.push({ before: state, after: canon(final), what: `move_scene "${card.headline}"` });
+    undone.length = 0;
+    const order = readingOrder(final.notes);
+    return ok(
+      `Moved "${card.headline}" to ${args.after ? "after" : "before"} "${target.headline}": ${removed} arrow(s) removed, ${drawn} drawn, the wall tidied along them${where(live)}. Story order now: ${order.map((note, index) => `${index + 1}. ${note.headline}`).join(", ")}. One undo takes the whole move back.`,
+      { order: order.map((note) => note.id) },
+    );
+  },
+);
+
 server.registerTool(
   "organize",
   {
     title: "Organize the wall",
     description:
-      "Tidy the wall along the arrows. Cards are ordered by their 'follows' arrows (a card comes after everything that points at it), then by reading order. With beats on the wall, each beat starts a row and the scenes that follow it fill the row to its right, wrapping under themselves when a run is long; with no beats yet, rows wrap five cards wide. Groups stay together. Pass noteIds to tidy only those cards, from their own top-left. Undoable from the wall.",
+      "Tidy the wall along the arrows. Cards are ordered by their 'follows' arrows (a card comes after everything that points at it), then by reading order. With beats on the wall, each beat starts a row and the scenes that follow it fill the row to its right, wrapping under themselves when a run is long; with no beats yet, rows wrap five cards wide. A group's cards keep their rows, so a group that spans beats spans rows. Pass noteIds to tidy only those cards, from their own top-left. Undoable from the wall.",
     inputSchema: { noteIds: z.array(z.string()).min(2).optional() },
   },
   async (args) => {
@@ -1186,15 +1306,17 @@ server.registerTool(
     for (const pose of poses) byRow.set(pose.y, [...(byRow.get(pose.y) ?? []), pose]);
     const wrappedUnder = [];
     let currentBeat = null;
+    let opening = 0;
     for (const y of [...byRow.keys()].sort((a, b) => a - b)) {
-      const first = byRow.get(y).sort((a, b) => a.x - b.x)[0];
-      const note = state.notes.find((item) => item.id === first.id);
+      const row = byRow.get(y).sort((a, b) => a.x - b.x);
+      const note = state.notes.find((item) => item.id === row[0].id);
       if (note?.rank === "beat") currentBeat = note;
-      else if (currentBeat && note && !wrappedUnder.some((item) => item.beat === currentBeat)) wrappedUnder.push({ beat: currentBeat, first: note });
+      else if (!currentBeat) opening += row.length;
+      else if (note && !wrappedUnder.some((item) => item.beat === currentBeat)) wrappedUnder.push({ beat: currentBeat, first: note });
     }
     const shape = beats
-      ? `${beats} row(s), one per beat${wrappedUnder.length ? `; ${wrappedUnder.map((item) => `the row of "${item.beat.headline}" wraps under from "${item.first.headline}"`).join(", ")}` : ""}`
-      : `${rows} row(s)`;
+      ? `${opening ? `an opening row of ${opening} card(s) before the first beat, then ` : ""}${beats} row(s), one per beat${wrappedUnder.length ? `; ${wrappedUnder.map((item) => `the row of "${item.beat.headline}" wraps under from "${item.first.headline}"`).join(", ")}` : ""}`
+      : `${rows} row(s) five cards wide — no beats yet, so nothing sets the rows; set_rank the turns and organize again for a row per beat`;
     return ok(`Organized ${poses.length} card(s) along the arrows into ${shape}${where(live)}.`, poses);
   },
 );
@@ -1328,8 +1450,9 @@ server.registerTool(
       if (!result) return ok(`No card with id ${args.id}. Call list_board.`);
       return ok(`Nothing changed: "${result.headline}" already reads that way.`);
     }
+    const lines = args.text.split("\n").filter((line) => line.trim()).length;
     return ok(
-      `Wrote "${result.headline}": ${formatPages(noteEighths(result))} page(s) measured${where(live)}.`,
+      `Wrote "${result.headline}": ${lines} line(s), measured at ${formatPages(noteEighths(result))} of a page (a page is 55 lines of Courier 12; a fraction is rounded up to an eighth)${where(live)}. While the text stands the card is measured, not estimated; its estimate is untouched underneath.`,
       result,
     );
   },
@@ -1509,7 +1632,7 @@ server.registerTool(
       );
     }
     const note = unwritten
-      ? [`${unwritten} of ${order.length} scenes are unwritten and count as one line each here; for the estimate from the cards' lengths, see list_board's runtime line.`]
+      ? [`${unwritten} of ${order.length} scenes are unwritten and count as one line each here, so this is the script so far, not the runtime: the estimate from the cards is about ${formatPages(boardEighths(state))} pages, the number to use until the scenes are written.`]
       : [];
     return ok([`pages: ${result.pageCount} of ${Math.round(state.targetEighths / 8)}`, ...note, ...lines].join("\n"), result.scenes);
   },
@@ -1729,7 +1852,7 @@ server.registerTool(
     const last = trail[trail.length - 1];
     if (!last) return ok(oneCall() ? "Nothing to undo here: through plotcoder-call every call is a fresh server, so undo works only from an MCP session. The writer can take any change back from the wall with ⌘Z." : "Nothing of mine to undo in this session.");
     const { state, rev, base } = await readBoard();
-    if (JSON.stringify(state) !== last.after) {
+    if (canon(state) !== last.after) {
       return ok(
         `Not undone: the board has changed since my ${last.what}. Undoing now would trample that. Ask the person to undo from the wall if they want it back.`,
       );
@@ -1757,11 +1880,11 @@ server.registerTool(
     const last = undone[undone.length - 1];
     if (!last) return ok("Nothing of mine to redo.");
     const { state, rev, base, boardId } = await readBoard();
-    if (JSON.stringify(state) !== JSON.stringify(last.before)) {
+    if (canon(state) !== canon(last.before)) {
       return ok(`Not redone: the board has changed since I undid my ${last.what}. Redoing now would trample that.`);
     }
     undone.pop();
-    const after = JSON.parse(last.after);
+    const after = normalizeState(JSON.parse(last.after));
     const live = await writeBoard(after, rev, base, boardId);
     trail.push(last);
     return ok(`Redid ${last.what}${where(live)}. ${undone.length} more can be redone.`, after);
@@ -1837,7 +1960,8 @@ server.registerTool(
         ? ok("Not renamed: that is already the name.")
         : ok(`No character with id ${args.id}. Call list_board for the cast.`);
     }
-    return ok(`Renamed to "${result.name}"${where(live)}.`, result);
+    const followed = state.notes.filter((note) => note.characterIds.includes(result.id)).length;
+    return ok(`Renamed to "${result.name}" (${result.id})${where(live)}; the name changed on ${followed} card${followed === 1 ? "" : "s"}.`, result);
   },
 );
 
@@ -1927,8 +2051,16 @@ server.registerTool(
       return ok("No place changed: those cards already read that way.");
     }
     const place = result[0].location;
+    // A near match on the wall is probably the same place spelled twice.
+    const wanted = (place ?? "").trim().toLowerCase();
+    const near = wanted
+      ? [...new Set(state.notes.map((note) => (note.location ?? "").trim()).filter(Boolean))].filter(
+          (other) => other.toLowerCase() !== wanted && (other.toLowerCase().includes(wanted) || wanted.includes(other.toLowerCase())),
+        )
+      : [];
+    const warn = near.length ? ` The wall also has ${near.map((other) => `"${other}"`).join(", ")} — the same place spelled twice, or two places? Each distinct phrase counts as one place.` : "";
     return ok(
-      `${result.length} card(s) now ${place ? `at ${place}` : "nowhere"}${where(live)}.`,
+      `${result.length} card(s) now ${place ? `at ${place}` : "nowhere"}${where(live)}.${warn}`,
       result,
     );
   },
@@ -2074,7 +2206,7 @@ server.registerTool(
   {
     title: "Create arrow",
     description:
-      "Draw a directed arrow from one card to another. kind 'follows' (the default) says what comes after what; kind 'setup' says the first card plants something the second pays off. Arrows are one-way: A→B does not create B→A. If you want both, call this twice — that is two arrows, not one two-headed line. A card cannot point at itself, and the same direction cannot be drawn twice, whatever its kind; use set_arrow_kind to change one.",
+      "Draw a directed arrow from one card to another. kind 'follows' (the default) says what comes after what — a straight sequence needs them too: organize lays the wall out along them, and the wall asks about a card no arrow touches; kind 'setup' says the first card plants something the second pays off. Arrows are one-way: A→B does not create B→A. If you want both, call this twice — that is two arrows, not one two-headed line. A card cannot point at itself, and the same direction cannot be drawn twice, whatever its kind; use set_arrow_kind to change one.",
     inputSchema: { from: z.string(), to: z.string(), kind: arrowKindSchema.optional() },
   },
   async (args) => {
@@ -2624,7 +2756,7 @@ server.registerTool(
     const next = renameBoard(project, target.id, args.name);
     if (next === project) return ok(`"${target.name}" already has that name.`);
     const live = await writeProject(next, boards, rev, base);
-    return ok(`Renamed to "${args.name.trim()}"${where(live)}.`);
+    return ok(`Renamed board "${target.name}" (${target.id}) to "${args.name.trim()}"${where(live)}.`, { id: target.id, name: args.name.trim() });
   },
 );
 
@@ -2662,9 +2794,12 @@ server.registerTool(
     inputSchema: { id: z.string() },
   },
   async (args) => {
+    const { state: before } = await readBoard();
+    const arrow = before.arrows.find((item) => item.id === args.id);
     const { changed, live } = await commit({ type: "delete_arrow", id: args.id });
     if (!changed) return ok(`No arrow with id ${args.id}. Call list_board for the real ids.`);
-    return ok(`Deleted that arrow${where(live)}. Any arrow the other way is untouched.`);
+    const name = (id) => `"${before.notes.find((note) => note.id === id)?.headline ?? id}"`;
+    return ok(`Deleted the ${arrow?.kind ?? "follows"} arrow ${name(arrow?.from)} → ${name(arrow?.to)}${where(live)}. Any arrow the other way is untouched.`);
   },
 );
 

package/src/board/readWall.d.ts

@@ -59,7 +59,8 @@ export type WallReading = {
   runs: Run[];
   setups: Setup[];
   /** Every planted card: the scene that pays it off (first setup arrow, by wall order), or null while unpaid. */
-  payoffs: Record<string, string | null>;
+  /** For each folded card, the cards its setup arrows land on, in wall order; empty when unpaid. */
+  payoffs: Record<string, string[]>;
   findings: Finding[];
 };
 

package/src/board/readWall.js

@@ -176,7 +176,7 @@ export function readWall(state) {
       findings.push({
         kind: "sag",
         ids: [longest.from, longest.to],
-        text: `About ${pages(longest.eighths)} pages run between "${headline(longest.from)}" and "${headline(longest.to)}"; the middle run here is about ${pages(typical)} (a beat's own pages are in no run). Is something sagging there, or is it one long set piece?`,
+        text: `About ${pages(longest.eighths)} pages run between "${headline(longest.from)}" and "${headline(longest.to)}"; the median run here is about ${pages(typical)} (a beat's own pages are in no run). Is something sagging there, or is it one long set piece?`,
       });
     }
   }
@@ -303,7 +303,9 @@ export function readWall(state) {
       .filter((arrow) => arrow.kind === "setup" && arrow.from === note.id)
       .map((arrow) => arrow.to)
       .sort((a, b) => (wallIndex.get(a) ?? Infinity) - (wallIndex.get(b) ?? Infinity));
-    payoffs[note.id] = heads[0] ?? null;
+    // Every payoff, in wall order: a card can plant two things (the ledger
+    // pays off at the cash and again at the initials), and both count.
+    payoffs[note.id] = heads;
   }
   for (const note of order) {
     if (note.plants && !paysOff.has(note.id)) {