plotcoder-board 0.1.38 → 0.1.39

package/README.md

@@ -43,7 +43,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-five 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_open` (a card the writer has not decided), `create_thread`, `update_thread` and `delete_thread` (a named string through cards, either end open until tied), `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 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. Ninety tools: reading (`list_board`, `read_wall`, `read_project`, `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_open` (a card the writer has not decided), `create_thread`, `update_thread` and `delete_thread` (a named string through cards, either end open until tied), `set_plant` (with `later`, `at` and `what`) and `set_payoff`, `set_alternative` and `choose_version` (two versions of one scene, one chosen), `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.
@@ -107,4 +107,4 @@ next round into a test of `claim_account` instead of the door it meant to test.
 
 ## Status
 
-Version 0.1.38. 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.39. 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.38",
+  "version": "0.1.39",
   "type": "module",
   "scripts": {
     "dev": "vite",

package/scripts/plotcoder-mcp-server.mjs

@@ -32,6 +32,7 @@ import {
   NOTE_HEIGHT,
   NOTE_WIDTH,
   DEFAULT_TARGET_EIGHTHS,
+  DEFAULT_NOTE_EIGHTHS,
   normalizeState,
   newId,
   noteEighths,
@@ -43,6 +44,7 @@ import { TEMPLATES } from "../src/board/templates.js";
 import { wordSentence, wordsAsText } from "../src/board/words.js";
 import { fromFountain, mergeFountain, toFountain } from "../src/board/fountain.js";
 import { toMarkdown, toPlainText } from "../src/board/markdown.js";
+import { cameraLines, cameraVerbs } from "../src/board/camera.js";
 import { fromProjectFile, toProjectFile } from "../src/board/projectFile.js";
 import { describeSetAside, fromFdx, toFdx } from "../src/board/fdx.js";
 import { paginate } from "../src/board/paginate.js";
@@ -806,6 +808,8 @@ const undone = [];
 /** The last read_wall's questions, and what changed since: a leave answers the reading in front of the agent (round thirteen, entry 19). */
 let lastReading = null;
 const sinceRead = [];
+/** Whether this session has read a wall yet: until it has, a write's tail counts the questions and points at read_wall; after, it quotes them (the handover's call 2). */
+let readOnce = false;
 /** 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;
 // The same question in the same words is the same question, whatever order its names come in (round seventeen, entry 21).
@@ -833,7 +837,13 @@ function changeNote() {
   lastChange = null;
   if (!change) return "";
   const parts = [];
-  if (change.gone.length || change.came.length) {
+  // Before the session's first reading a tail counts and points: a build is
+  // twelve writes whose quoted questions the next write answers (round
+  // fifteen 9, eighteen 20). After it, a change is to something read, and
+  // the tail quotes it.
+  if (!readOnce && (change.gone.length || change.came.length)) {
+    parts.push(`the wall's questions have changed since your last read_wall: ${change.asks} now${change.came.length ? `, ${change.came.length} of them new` : ""} — read_wall lists them`);
+  } else if (change.gone.length || change.came.length) {
     parts.push(
       `the wall now asks ${change.asks} question${change.asks === 1 ? "" : "s"}${change.gone.length ? ` (gone: ${change.gone.map((finding) => `[${finding.kind}] ${finding.text.replace(/\.$/, "")}`).join(" ")})` : ""}${change.came.length ? ` (new: ${change.came.map((finding) => `[${finding.kind}] ${finding.text.replace(/\.$/, "")}`).join(" ")})` : ""}`,
     );
@@ -964,8 +974,27 @@ function workingProject(id, name, count) {
 }
 
 /** Where a change landed, for the tail of a tool's reply. */
+/** Who has a wall of the working project open on a screen now, from the presence the server already follows (the handover's call 4); never the agent itself. */
+function presentPeople() {
+  try {
+    const state = accountDoor?.channel?.presenceState?.() ?? {};
+    const names = new Set();
+    for (const entries of Object.values(state)) for (const entry of entries ?? []) if (entry && typeof entry.name === "string" && !/^an agent, as /.test(entry.name)) names.add(entry.name);
+    return [...names];
+  } catch {
+    return [];
+  }
+}
+
+/** The account tail says what the wall shows: open on whose screen, or no wall open, never a bare "live". */
+function accountTail() {
+  const people = presentPeople();
+  if (!people.length) return " (saved to the account; no wall open right now — it shows the moment one opens)";
+  return ` (saved to the account; open on ${people.length === 1 ? `${people[0]}'s screen` : `${people.length} screens: ${people.join(", ")}`} now)`;
+}
+
 function where(live) {
-  const tail = live === ACCOUNT ? " (saved to the account; live on every open wall)" : live ? " (visible on the open board)" : " (written to file; the wall shows it the next time the app runs from this folder)";
+  const tail = live === ACCOUNT ? accountTail() : live ? " (visible on the open board)" : " (written to file; the wall shows it the next time the app runs from this folder)";
   return `${tail}${changeNote()}`;
 }
 
@@ -1038,6 +1067,25 @@ function stillOpen(notes) {
   return ` ${open.length === 1 ? `"${open[0].headline}" is still open (${open[0].open})` : `${open.length} of them are still open`}: the words stay until set_open "" clears them, and the wall asks nothing else of ${open.length === 1 ? "it" : "them"} until then.`;
 }
 
+/** "20 under", "3 over" or "on it", against a target in eighths. */
+function againstWord(state, targetEighths) {
+  const total = boardEighths(state);
+  return total > targetEighths ? `${formatPages(total - targetEighths)} over` : total < targetEighths ? `${formatPages(targetEighths - total)} under` : "on it";
+}
+
+/** The written scenes measured under the page they were read as (the handover's call 7, four rounds): a sketch is counted as measured and named. */
+function sketches(state) {
+  return state.notes.filter((note) => isMeasured(note) && noteEighths(note) < (note.lengthEighths ?? DEFAULT_NOTE_EIGHTHS));
+}
+
+/** The runtime's second number while a sketch stands: what the cards would come to if each sketch ran to the page it was read as. */
+function sketchLine(state) {
+  const found = sketches(state);
+  if (!found.length) return "";
+  const ifRan = boardEighths(state) + found.reduce((sum, note) => sum + ((note.lengthEighths ?? DEFAULT_NOTE_EIGHTHS) - noteEighths(note)), 0);
+  return `; ${found.length} written scene${found.length === 1 ? " is a sketch" : "s are sketches"}, measured under the page ${found.length === 1 ? "it was" : "they were"} read as: about ${formatPages(ifRan)} pages if ${found.length === 1 ? "it" : "they"} ran to that`;
+}
+
 /** 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));
@@ -1072,7 +1120,8 @@ function summarize(state) {
       const count = formatPages(noteEighths(note));
       // A written card's estimate is kept underneath for when the text goes; say it, or it is invisible (round sixteen, entry 44).
       const underneath = isMeasured(note) && note.lengthEighths !== null ? `; the writer's estimate underneath: ${formatPages(note.lengthEighths)}` : "";
-      const pages = isMeasured(note) ? `${count} ${count === "1" ? "page" : "pages"}, written${underneath}` : note.lengthEighths === null ? "about a page, unsized" : `${count} ${count === "1" ? "page" : "pages"}`;
+      const sketch = isMeasured(note) && noteEighths(note) < (note.lengthEighths ?? DEFAULT_NOTE_EIGHTHS) ? " (a sketch: under the page it was read as)" : "";
+      const pages = isMeasured(note) ? `${count} ${count === "1" ? "page" : "pages"}, written${sketch}${underneath}` : note.lengthEighths === null ? "about a page, unsized" : `${count} ${count === "1" ? "page" : "pages"}`;
       return `  - ${note.id} [${note.rank ?? "scene"}, ${pages}${who}${place}${when}${openWord}${plant}${pays}${revised}] — "${note.headline}" (${note.color}) at ${Math.round(note.x)},${Math.round(note.y)}`;
     })
     .join("\n");
@@ -1142,12 +1191,17 @@ function summarize(state) {
     ...production,
     `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${runtimeKinds(state)}`
-      : `runtime: about ${formatPages(runtime)} pages of the ${formatPages(state.targetEighths)}-page target the writer set (set_target changes it) — ${over > 0 ? `${formatPages(over)} over` : over < 0 ? `${formatPages(-over)} under` : "on it"} (an estimate from the cards; a page runs about a minute; page_count is the script so far)${runtimeKinds(state)}`,
+    state.targetOpen
+      ? `runtime: about ${formatPages(runtime)} pages (an estimate from the cards; a page runs about a minute); target open, by the writer's word — "${state.targetOpen}" (against 30 it would be ${againstWord(state, 30 * EIGHTHS_PER_PAGE)}; against 120, ${againstWord(state, 120 * EIGHTHS_PER_PAGE)}; set_target decides it)${runtimeKinds(state)}${sketchLine(state)}`
+      : 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${runtimeKinds(state)}${sketchLine(state)}`
+      : `runtime: about ${formatPages(runtime)} pages of the ${formatPages(state.targetEighths)}-page target the writer set (set_target changes it) — ${over > 0 ? `${formatPages(over)} over` : over < 0 ? `${formatPages(-over)} under` : "on it"} (an estimate from the cards; a page runs about a minute; page_count is the script so far)${runtimeKinds(state)}${sketchLine(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)",
+    ...(state.notes.some((note) => note.alternativeOf)
+      ? ["versions, not chosen (behind their front cards; out of the order, the count and the pages; choose_version decides):", ...state.notes.filter((note) => note.alternativeOf).map((note) => `  - ${note.id} — "${note.headline}", a version of "${state.notes.find((item) => item.id === note.alternativeOf)?.headline ?? note.alternativeOf}"`)]
+      : []),
     "rows on the wall (top to bottom, left to right; ★ a beat):",
     ...(rowLines.length ? rowLines : ["  (no cards)"]),
     "cast (the project's; every board of it casts from here; read_character reads a person's whole page, update_character writes it):",
@@ -1316,15 +1370,20 @@ server.registerTool(
   {
     title: "Set target length",
     description:
-      "Set the board's target script length, in pages or in minutes (a page runs about a minute): 120 for a feature, 30 for a half-hour, 60 for an hour drama. This is what the runtime estimate is measured against.",
-    inputSchema: { pages: pagesSchema.optional(), minutes: z.number().positive().optional() },
+      "Set the board's target script length, in pages or in minutes (a page runs about a minute): 120 for a feature, 30 for a half-hour, 60 for an hour drama. This is what the runtime estimate is measured against. Or leave the target open: pass open with the writer's words for why it is not decided — \"half-hour or feature\" — and the reading lists it under open, by the writer's word, and reads the runtime against both defaults while the words stand; a number decides it, open \"\" takes the words back.",
+    inputSchema: { pages: pagesSchema.optional(), minutes: z.number().positive().optional(), open: z.string().optional() },
   },
   async (args) => {
-    if (args.pages === undefined && args.minutes === undefined) return ok("Say the target in pages or in minutes.");
-    const { state, live } = await commit({
+    if (args.pages === undefined && args.minutes === undefined && args.open === undefined) return ok("Say the target in pages or in minutes, or open with the writer's words for why it is not decided.");
+    const { state, changed, live } = await commit({
       type: "set_target",
-      targetEighths: toEighths(args.pages ?? args.minutes),
+      ...(args.pages !== undefined || args.minutes !== undefined ? { targetEighths: toEighths(args.pages ?? args.minutes) } : {}),
+      ...(args.open !== undefined ? { open: args.open } : {}),
     });
+    if (!changed) return ok("Target unchanged: it already read that way.");
+    if (state.targetOpen) {
+      return ok(`Target left open, by the writer's word: "${state.targetOpen}"${where(live)}. The reading lists it and reads the cards against a half-hour and a feature meanwhile: about ${formatPages(boardEighths(state))} pages — against 30, ${againstWord(state, 30 * EIGHTHS_PER_PAGE)}; against 120, ${againstWord(state, 120 * EIGHTHS_PER_PAGE)}. set_target with pages or minutes decides it.`, { targetEighths: state.targetEighths, targetOpen: state.targetOpen });
+    }
     return ok(
       `Target is ${formatPages(state.targetEighths)} pages${where(live)}. The cards add up to about ${formatPages(boardEighths(state))} — ${boardEighths(state) > state.targetEighths ? `${formatPages(boardEighths(state) - state.targetEighths)} over` : `${formatPages(state.targetEighths - boardEighths(state))} under`}.`,
       { targetEighths: state.targetEighths },
@@ -1567,6 +1626,7 @@ server.registerTool(
     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;
+    readOnce = true;
     const runs = describeRuns(reading, state).map((line, index) => {
       const ids = reading.runs[index]?.ids ?? [];
       return ids.length ? `${line} — ${ids.map((id) => `"${state.notes.find((note) => note.id === id)?.headline ?? id}"`).join(", ")}` : line;
@@ -1582,6 +1642,7 @@ server.registerTool(
     // Fields left open by the writer's word (R61): the logline and the whens are the reading's; the premise and the board's name are the project's.
     const openFieldLines = [
       ...(projectForRead.nameOpen ? [`  - the project's name — ${projectForRead.nameOpen}`] : []),
+      ...(state.targetOpen ? [`  - the target — ${state.targetOpen}`] : []),
       ...reading.openFields.filter((field) => field.field === "logline").map((field) => `  - the logline — ${field.words}`),
       ...(projectForRead.premiseOpen ? [`  - the premise — ${projectForRead.premiseOpen}`] : []),
       ...(readBoardMeta?.nameOpen ? [`  - this board's name — ${readBoardMeta.nameOpen}`] : []),
@@ -1610,9 +1671,11 @@ server.registerTool(
       ...(projectForRead.premiseOpen ? [`premise: open, by the writer's word — "${projectForRead.premiseOpen}"`] : []),
       `logline: ${state.loglineOpen ? `open, by the writer's word — "${state.loglineOpen}"` : state.logline ? `"${state.logline}"` : "(none yet)"}`,
       "the cast and the places are list_board's, not the reading's",
-      state.targetEighths === DEFAULT_TARGET_EIGHTHS
-        ? `runtime: about ${formatPages(boardEighths(state))} pages (${whose || "no cards"}); no target set (set_target)`
-        : `runtime: about ${formatPages(boardEighths(state))} pages of the ${formatPages(state.targetEighths)}-page target the writer set (set_target changes it) — ${boardEighths(state) > state.targetEighths ? `${formatPages(boardEighths(state) - state.targetEighths)} over` : boardEighths(state) < state.targetEighths ? `${formatPages(state.targetEighths - boardEighths(state))} under` : "on it"} (${whose || "no cards"}; page_count is the script so far)`,
+      state.targetOpen
+        ? `runtime: about ${formatPages(boardEighths(state))} pages (${whose || "no cards"}); target open, by the writer's word — "${state.targetOpen}" (against 30 it would be ${againstWord(state, 30 * EIGHTHS_PER_PAGE)}; against 120, ${againstWord(state, 120 * EIGHTHS_PER_PAGE)})${sketchLine(state)}`
+        : state.targetEighths === DEFAULT_TARGET_EIGHTHS
+        ? `runtime: about ${formatPages(boardEighths(state))} pages (${whose || "no cards"}); no target set (set_target)${sketchLine(state)}`
+        : `runtime: about ${formatPages(boardEighths(state))} pages of the ${formatPages(state.targetEighths)}-page target the writer set (set_target changes it) — ${boardEighths(state) > state.targetEighths ? `${formatPages(boardEighths(state) - state.targetEighths)} over` : boardEighths(state) < state.targetEighths ? `${formatPages(state.targetEighths - boardEighths(state))} under` : "on it"} (${whose || "no cards"}; page_count is the script so far)${sketchLine(state)}`,
       `groups: ${
         state.groups.length
           ? state.groups
@@ -1643,6 +1706,9 @@ server.registerTool(
       ...(reading.open.length || openFieldLines.length
         ? ["open, by the writer's word (listed, not asked about while the words stand; set_open with \"\" closes a card, the field's own tool with open \"\" a field):", ...openFieldLines, ...reading.open.map((item) => `  - "${state.notes.find((note) => note.id === item.id)?.headline ?? item.id}" — ${item.words}${item.hides.length ? ` (closed, it would be asked ${item.hides.map((kind) => ASK_WORDS[kind] ?? CHECK_WORDS[kind] ?? kind).join("; ")})` : ""}`)]
         : []),
+      ...(reading.versions.length
+        ? ["two versions, not chosen (the front card is in the story; choose_version decides):", ...reading.versions.map((pair) => `  - "${state.notes.find((note) => note.id === pair.id)?.headline ?? pair.id}" or ${pair.alternatives.map((id) => `"${state.notes.find((note) => note.id === id)?.headline ?? id}"`).join(" or ")}`)]
+        : []),
       ...(reading.threads.length
         ? ["threads (the writer's strings through the story; a loose end is asked about below):", ...reading.threads.map((thread) => `  - "${thread.name}": ${thread.ids.length ? thread.ids.map((id) => `"${state.notes.find((note) => note.id === id)?.headline ?? id}"`).join(" → ") : "no card yet"}${thread.startOpen ? " — starts nowhere yet" : ""}${thread.endOpen ? " — ends nowhere yet" : ""}${!thread.startOpen && !thread.endOpen && thread.ids.length >= 2 ? ` — both ends tied, about ${formatPages(thread.apart)} pages apart` : ""}`)]
         : []),
@@ -2223,7 +2289,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 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${(() => {
+      `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${noteEighths(result) < (result.lengthEighths ?? DEFAULT_NOTE_EIGHTHS) ? " — a sketch: shorter than the page it was read as; the wall counts the measure and says so" : ""}${(() => { const found = cameraLines(result.text); return found.length ? ` — ${found.length} line${found.length === 1 ? "" : "s"} the camera cannot see (${cameraVerbs(found).join(", ")}): the reminder "Write for the camera" is the house's; show it or cut it, on the writer's word` : ""; })()}${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${(() => {
         // How far the measure sits from what the card was read as before (round eighteen, entry 43): the writer's estimate, or the page an unsized card is read as.
         const before = result.lengthEighths !== null ? result.lengthEighths : 8;
         const label = result.lengthEighths !== null ? `the writer's ${formatPages(result.lengthEighths)} pages` : "the page an unsized card is read as";
@@ -2290,6 +2356,7 @@ server.registerTool(
     let index = 0;
     // The changed lines of the scene being printed, starred in the right margin as plain text stars them (round sixteen, entry 32).
     let changedTexts = new Set();
+    let cameraByText = new Map();
     for (const line of text.split("\n")) {
       if (/^\.(?!\.)/.test(line) && index < ids.length) {
         const note = state.notes.find((item) => item.id === ids[index]);
@@ -2300,9 +2367,14 @@ server.registerTool(
         const sourceLines = (note?.text ?? "").split("\n");
         changedTexts = new Set([...(mark?.lines ?? [])].map((at) => sourceLines[at]).filter((item) => item && item.trim()));
         const revised = mark?.revised ? ` · changed in the ${state.revision.color} revision${changedTexts.size ? ` (${changedTexts.size} line${changedTexts.size === 1 ? "" : "s"} starred below)` : ""}` : "";
-        lines.push(`${line}    [[id: ${note?.id ?? "?"} · ${note && isMeasured(note) ? "measured" : "estimated"} ${formatPages(note ? noteEighths(note) : 0)}pp${standIn}${numbered}${revised}]]`);
+        // The lines the camera cannot see (the handover's call 6): marked on the page, never asked on the wall.
+        const camera = note ? cameraLines(note.text ?? "") : [];
+        cameraByText = new Map(camera.map((item) => [item.line, item.verbs]));
+        const cameraNote = camera.length ? ` · camera: ${camera.length} line${camera.length === 1 ? "" : "s"} it cannot see (${cameraVerbs(camera).join(", ")})` : "";
+        lines.push(`${line}    [[id: ${note?.id ?? "?"} · ${note && isMeasured(note) ? "measured" : "estimated"} ${formatPages(note ? noteEighths(note) : 0)}pp${standIn}${numbered}${revised}${cameraNote}]]`);
       } else {
-        lines.push(changedTexts.has(line) ? `${line}    *` : line);
+        const verbs = cameraByText.get(line.trim());
+        lines.push(`${line}${changedTexts.has(line) ? "    *" : ""}${verbs ? `    ◂ ${verbs.join(", ")}` : ""}`);
       }
     }
     return ok(lines.join("\n"));
@@ -2785,6 +2857,56 @@ server.registerTool(
 // The open card (R59): the writer's word that a card is not decided. The
 // per-card twin of leave_question — that one leaves a question, this one
 // leaves a card.
+/**
+ * Two versions of one scene (R65, the handover's call 5 on Robert's word):
+ * a card set behind another as its other version leaves the story — the
+ * order, the count, the pages, every export — and waits there; the reading
+ * lists the pair and asks nothing of it until the writer chooses.
+ */
+server.registerTool(
+  "set_alternative",
+  {
+    title: "Another version of a scene",
+    description:
+      "Set a card behind another as its other version — two endings, two ways a scene could go — by id or headline. The version leaves the story: out of the order, the count, the pages and every export; its follows arrows are dropped (setup arrows stay). The wall draws it tucked behind its sibling; read_wall lists the pair under \"two versions, not chosen\" and asks nothing of it; choose_version decides. of: \"\" takes a card out from behind and it stands as a plain card again. Only on the writer's word: two versions the notes hold, never two the agent could not choose between.",
+    inputSchema: { id: z.string(), of: z.string() },
+  },
+  async (args) => {
+    const { state: current } = await readBoard();
+    const byRef = (ref) => current.notes.find((note) => note.id === ref) ?? current.notes.find((note) => note.headline.trim().toLowerCase() === ref.trim().toLowerCase()) ?? null;
+    const card = byRef(args.id);
+    if (!card) return ok(`No card with id or headline "${args.id}". Call list_board.`);
+    const front = args.of.trim() ? byRef(args.of) : null;
+    if (args.of.trim() && !front) return ok(`No card with id or headline "${args.of}". Call list_board.`);
+    if (front?.alternativeOf) return ok(`"${front.headline}" is itself a version of another card; set the version behind the front card, "${current.notes.find((note) => note.id === front.alternativeOf)?.headline ?? front.alternativeOf}".`);
+    if (front && current.notes.some((note) => note.alternativeOf === card.id)) return ok(`"${card.headline}" has a version behind it already; choose_version there first.`);
+    const { state, changed, result, live } = await commit({ type: "set_alternative", id: card.id, of: front ? front.id : null });
+    if (!changed) return ok(front ? `"${card.headline}" already stands behind "${front.headline}".` : `"${card.headline}" is not a version of another card.`);
+    if (!front) return ok(`"${card.headline}" stands as a plain card again, unwired${where(live)}: create_arrow or move_scene puts it in the order.`, result);
+    return ok(`"${card.headline}" is now the other version of "${front.headline}"${where(live)}: out of the order, the count and the pages${result.arrowsDropped ? `, ${result.arrowsDropped} follows arrow${result.arrowsDropped === 1 ? "" : "s"} dropped` : ""}. The reading lists the pair as two versions, not chosen, and asks nothing of it; choose_version decides. The wall draws it tucked behind its sibling.`, result);
+  },
+);
+
+server.registerTool(
+  "choose_version",
+  {
+    title: "Choose a version",
+    description:
+      "Choose one of two versions of a scene, by id or headline: the chosen card is the scene, in the front card's place — its arrows, its rank, its group; the other goes, or with keep true stands beside it as a plain unwired card. Only on the writer's word.",
+    inputSchema: { id: z.string(), keep: z.boolean().optional() },
+  },
+  async (args) => {
+    const { state: current } = await readBoard();
+    const card = current.notes.find((note) => note.id === args.id) ?? current.notes.find((note) => note.headline.trim().toLowerCase() === args.id.trim().toLowerCase());
+    if (!card) return ok(`No card with id or headline "${args.id}". Call list_board.`);
+    const other = card.alternativeOf ? current.notes.find((note) => note.id === card.alternativeOf) : current.notes.find((note) => note.alternativeOf === card.id);
+    if (!other) return ok(`"${card.headline}" has no other version; nothing to choose.`);
+    const { changed, result, live } = await commit({ type: "choose_version", id: card.id, keep: args.keep === true });
+    if (!changed) return ok("Nothing chosen.");
+    return ok(`Chose "${card.headline}"${result.steppedForward ? ` — it steps forward into "${other.headline}"'s place, with its arrows, rank and group` : ""}${where(live)}. "${other.headline}" ${result.kept ? "stands beside it as a plain card, unwired" : "is gone"}.`, result);
+  },
+);
+
 server.registerTool(
   "set_open",
   {
@@ -3735,7 +3857,7 @@ server.registerTool(
     return ok(
       [
         `projects: ${projects.length} (as ${account.email})${projects.length === 0 ? ` — ${noProjectYet()}` : ""}`,
-        ...projects.map((row) => `  - ${row.id} — "${row.record.name}"${row.id === account.projectId ? " (working)" : ""}: ${row.record.boards.length} board(s) · ${(row.people ?? []).join(", ")}`),
+        ...projects.map((row) => `  - ${row.id} — "${row.record.name}"${row.id === account.projectId ? " (working)" : ""}: ${row.record.boards.length} board(s) · ${(row.people ?? []).join(", ")}${row.id === account.projectId ? (() => { const people = presentPeople(); return people.length ? ` · open now on ${people.length} screen${people.length === 1 ? "" : "s"}: ${people.join(", ")}` : " · no wall open right now"; })() : ""}`),
       ].join("\n"),
       projects.map((row) => ({ id: row.id, name: row.record.name, boards: row.record.boards.length, people: row.people })),
     );
@@ -3813,7 +3935,7 @@ server.registerTool(
     title: "Start a project",
     description:
       "Through the account door: start a new project of the writer's with this name — one empty board, nothing on it — and work it from now on. The writer sees it under Projects on every device. A title not decided: open with the writer's words (\"The Allotments, or Plot 14\") instead of a name, and the project starts as Untitled project with those words beside it. board names the first board; boardOpen leaves its name open in the writer's words instead (\"the pilot, or the film\"), so a board born from a maybe is not silently \"Board 1\".",
-    inputSchema: { name: z.string().min(1).optional(), open: z.string().optional(), board: z.string().optional(), boardOpen: z.string().optional(), pages: pagesSchema.optional(), minutes: z.number().positive().optional() },
+    inputSchema: { name: z.string().min(1).optional(), open: z.string().optional(), board: z.string().optional(), boardOpen: z.string().optional(), pages: pagesSchema.optional(), minutes: z.number().positive().optional(), targetOpen: z.string().optional().describe("The writer's words for why the length is not decided — \"half-hour or feature\" — so the target is born open instead of the feature default standing unsaid.") },
   },
   async (args) => {
     const account = await findAccount();
@@ -3829,12 +3951,12 @@ server.registerTool(
     const inserted = await account.client.from("projects").insert({ id: record.id, record, reminders: null, rev: 1 });
     if (inserted.error) return ok(`Could not start the project: ${inserted.error.message}`);
     const target = args.pages ?? args.minutes;
-    const state = target === undefined ? emptyState() : { ...emptyState(), targetEighths: toEighths(target) };
+    const state = { ...emptyState(), ...(target === undefined ? {} : { targetEighths: toEighths(target) }), ...(args.targetOpen?.trim() && target === undefined ? { targetOpen: args.targetOpen.trim().replace(/\s+/g, " ") } : {}) };
     const board = await account.client.from("boards").insert({ id: record.activeBoardId, project_id: record.id, state, rev: 1, updated_by: null });
     if (board.error) return ok(`Started "${record.name}" but could not make its first board: ${board.error.message}`);
     workingProject(record.id, record.name, (account.projectCount ?? 0) + 1);
     joinPresence(record.id);
-    const targetLine = target === undefined ? ` Its target is ${formatPages(state.targetEighths)} pages, the default for a feature; set_target for a pilot or a half-hour, or pass pages or minutes here.` : ` Its target is ${formatPages(state.targetEighths)} pages.`;
+    const targetLine = state.targetOpen ? ` Its target is left open, by the writer's word: "${state.targetOpen}"; the reading reads the cards against a half-hour and a feature until set_target decides it.` : target === undefined ? ` Its target is ${formatPages(state.targetEighths)} pages, the default for a feature; set_target for a pilot or a half-hour, or pass pages or minutes here.` : ` Its target is ${formatPages(state.targetEighths)} pages.`;
     const first = record.boards[0];
     const nameOpenLine = `${record.nameOpen ? ` The project's name is left open, by the writer's word: "${record.nameOpen}"; rename_project decides it.` : ""}${first.nameOpen ? ` The board's name is left open, by the writer's word: "${first.nameOpen}"; rename_board decides it.` : ""}`;
     return ok(`Started "${record.name}" (${record.id}) with its first board "${first.name}" (${first.id}), and working it now, as ${account.email}.${targetLine}${nameOpenLine}${oneCallHint(record)}`, { id: record.id, name: record.name, boardId: first.id, boardName: first.name, boardNameOpen: first.nameOpen ?? "", targetEighths: state.targetEighths });

package/src/board/agents.js

@@ -23,7 +23,7 @@ export const AGENTS = {
     {
       id: "hosted",
       name: "The hosted door, with nothing installed",
-      text: "Where someone runs PlotCoder's server for you — npx -y plotcoder-board@latest serve puts it on a port, and the repo has a Dockerfile — an MCP client connects over HTTP with the writer's sign-in on the request: claude mcp add plotcoder --transport http https://<that host>/mcp --header \"Authorization: Basic <base64 of email:password>\", then start the session again. The same server, the same tools, the account as the wall, no disk. PlotCoder does not run a public one yet; the address is the writer's to give.",
+      text: "Where someone runs PlotCoder's server for you — npx -y plotcoder-board@latest serve puts it on a port, and the repo has a Dockerfile — an MCP client connects over HTTP with the writer's sign-in on the request: claude mcp add plotcoder --transport http https://<that host>/mcp --header \"Authorization: Basic <base64 of email:password>\", then start the session again. The same server, the same tools, the account as the wall, no disk. PlotCoder runs one, as a Supabase Edge Function: https://kmpahjsggbleygsnuwug.supabase.co/functions/v1/mcp — claude mcp add plotcoder --transport http https://kmpahjsggbleygsnuwug.supabase.co/functions/v1/mcp --header \"Authorization: Basic <base64 of email:password>\", or in the Claude desktop app, Settings › Connectors › add a custom connector with that address and header: the app keeps a connector in its own settings, where a stdio block in a file can vanish. The password rides in the header, base64 over https, as the env block carries it; share a machine and know it.",
     },
     {
       id: "account",

package/src/board/camera.d.ts

@@ -0,0 +1,4 @@
+// Type surface for camera.js — the lines the camera cannot see.
+export type CameraLine = { at: number; line: string; verbs: string[] };
+export declare function cameraLines(text: string): CameraLine[];
+export declare function cameraVerbs(found: CameraLine[]): string[];

package/src/board/camera.js

@@ -0,0 +1,52 @@
+// What the camera cannot see (the handover's call 6, round eighteen entry
+// 44): a line of action that says what someone knows, feels, thinks or
+// wants is a fact the page states and the screen cannot show. The house
+// principle "write for the camera and the cut" is a reminder every project
+// starts with; this marks the lines it is about, on the page and in the
+// write's reply, and never asks a question on the wall — a sentence on a
+// page is the writer's. Only action is read: a character cue and the
+// dialogue under it are theirs to say.
+
+/** Interior verbs, as they appear in present- and past-tense action. */
+const INTERIOR = [
+  "knows", "knew", "feels", "felt", "thinks", "thought", "remembers", "remembered",
+  "realises", "realizes", "realised", "realized", "wants", "wanted", "decides", "decided",
+  "understands", "understood", "wonders", "wondered", "hopes", "hoped", "believes", "believed",
+  "fears", "feared", "regrets", "regretted", "loves", "loved", "hates", "hated",
+];
+const INTERIOR_RE = new RegExp(`\\b(${INTERIOR.join("|")})\\b`, "gi");
+
+/** A character cue: capitals and little else, short, no ending full stop; dialogue follows it until a blank line. */
+function isCue(line) {
+  const trimmed = line.trim();
+  if (!trimmed || trimmed.length > 40) return false;
+  if (/[.!?]$/.test(trimmed) && !/\(V\.O\.\)|\(O\.S\.\)|\(CONT'D\)$/i.test(trimmed)) return false;
+  const letters = trimmed.replace(/[^A-Za-z]/g, "");
+  return letters.length >= 2 && letters === letters.toUpperCase();
+}
+
+/**
+ * The action lines the camera cannot see, with the verbs that say so:
+ * `{ at, line, verbs }` per line, in order. Headings (a leading dot),
+ * cues, dialogue and parentheticals are skipped.
+ */
+export function cameraLines(text) {
+  const lines = (text ?? "").split("\n");
+  const found = [];
+  let inDialogue = false;
+  for (const [at, line] of lines.entries()) {
+    const trimmed = line.trim();
+    if (!trimmed) { inDialogue = false; continue; }
+    if (trimmed.startsWith(".") || trimmed.startsWith("(")) continue;
+    if (isCue(trimmed)) { inDialogue = true; continue; }
+    if (inDialogue) continue;
+    const verbs = [...new Set([...trimmed.matchAll(INTERIOR_RE)].map((match) => match[1].toLowerCase()))];
+    if (verbs.length) found.push({ at, line: trimmed, verbs });
+  }
+  return found;
+}
+
+/** The verbs across every marked line, once each, in order of first use. */
+export function cameraVerbs(found) {
+  return [...new Set(found.flatMap((item) => item.verbs))];
+}

package/src/board/readWall.d.ts

@@ -73,6 +73,8 @@ export type WallReading = {
   open: Array<{ id: string; words: string; hides: FindingKind[] }>;
   /** Fields left open by the writer's word (R61): the board's logline, and each card's when, in story order. Listed, not asked. */
   openFields: Array<{ field: "logline"; words: string } | { field: "location"; id: string; words: string } | { field: "when"; id: string; words: string }>;
+  /** Two versions of one scene (R65): each front card with the versions behind it, in story order; listed, never asked. */
+  versions: Array<{ id: string; alternatives: string[] }>;
   /** Threads (R60): each named string with its cards in story order and which ends are open. */
   threads: Array<{ id: string; name: string; ids: string[]; startOpen: boolean; endOpen: boolean; /** Eighths from the first card's start to the last card's start; 0 with fewer than two cards. */ apart: number }>;
   /** Cards here that pay off a fold of another board (R58), composed by the door from the project. */

package/src/board/readWall.js

@@ -516,6 +516,8 @@ export function readWall(state, options = {}) {
     paidBy: paidHere,
     open: describeOpen(state, options, order, openIds),
     openFields: describeOpenFields(state, order),
+    // Two versions of one scene (R65): the front card and the one behind it, in story order; listed, never asked.
+    versions: order.filter((note) => state.notes.some((item) => item.alternativeOf === note.id)).map((note) => ({ id: note.id, alternatives: state.notes.filter((item) => item.alternativeOf === note.id).map((item) => item.id) })),
     threads,
     findings: asked,
     left,

package/src/board/reducer.d.ts

@@ -81,6 +81,8 @@ export type BoardNote = {
   plants: boolean;
   /** What the fold plants, in the writer's words (R62), or empty; never set on an unfolded card. */
   plantsWhat: string;
+  /** Another version of another card (R65): the id of the card this one stands behind, or null. A version is out of the order, the count and the pages until chosen. */
+  alternativeOf: string | null;
   /** 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. */
@@ -120,6 +122,8 @@ export type BoardState = {
   logline: string;
   /** The writer's words for why there is no logline yet (R61), or empty. */
   loglineOpen: string;
+  /** The writer's words for why the target is not decided, or empty; the number stands as the default meanwhile. */
+  targetOpen: string;
   /** Target script length in eighths of a page; 120 pages for a feature (R25). */
   targetEighths: number;
   /** The roster: every person in the story, whether or not they are on a card yet (R29). */
@@ -169,7 +173,7 @@ export type Command =
   | { type: "set_logline"; logline?: string; open?: string }
   | { type: "set_rank"; ids: string[]; rank: NoteRank }
   | { type: "set_length"; ids: string[]; lengthEighths: number | null }
-  | { type: "set_target"; targetEighths: number }
+  | { type: "set_target"; targetEighths?: number; open?: string }
   | {
       type: "create_note";
       id?: string;
@@ -218,6 +222,8 @@ export type Command =
   | { type: "set_cast"; ids: string[]; characterIds: string[] }
   | { type: "set_plant"; ids: string[]; plants?: boolean; what?: string }
   | { type: "set_open"; ids: string[]; open: string }
+  | { type: "set_alternative"; id: string; of: string | null }
+  | { type: "choose_version"; id: string; keep?: boolean }
   | { type: "set_payoff_board"; ids: string[]; boardId: string | null; noteId?: string | null }
   | { type: "set_location"; ids: string[]; location?: string; open?: string }
   | { type: "set_when"; ids: string[]; when?: string; open?: string }
@@ -250,3 +256,8 @@ export declare function applyCommand(
   command: Command,
   now?: string,
 ): CommandResult;
+
+/** Rows top to bottom, cards left to right within a row (moved here for R62). */
+export declare function readingOrder(notes: BoardNote[]): BoardNote[];
+/** The follows arrows where they exist, reading order where they do not; versions of other cards left out (R56, R65). */
+export declare function storyOrder(state: BoardState, ids?: string[]): BoardNote[];

package/src/board/reducer.js

@@ -167,7 +167,7 @@ export function isMeasured(note) {
 }
 
 export function boardEighths(state) {
-  return state.notes.reduce((total, note) => total + noteEighths(note), 0);
+  return state.notes.reduce((total, note) => total + (note.alternativeOf ? 0 : noteEighths(note)), 0);
 }
 
 /**
@@ -220,6 +220,7 @@ export function emptyState() {
   return {
     logline: "",
     targetEighths: DEFAULT_TARGET_EIGHTHS,
+    targetOpen: "",
     loglineOpen: "",
     characters: [],
     notes: [],
@@ -256,6 +257,8 @@ export function seedState(now = nowIso()) {
     plants: false,
     // What the fold plants, in the writer's words (R62), or nothing.
     plantsWhat: "",
+    // Another version of another card (R65): the card this one stands behind, or null.
+    alternativeOf: null,
     // A fold that pays off on another board — a later episode — names it here;
     // null claims nothing (R50). The scene there that pays it off, once one
     // does (R58); null while the board is a promise.
@@ -274,6 +277,7 @@ export function seedState(now = nowIso()) {
     // new writer finds out the logline is there at all.
     logline: "",
     targetEighths: DEFAULT_TARGET_EIGHTHS,
+    targetOpen: "",
     loglineOpen: "",
     // Two people, cast on the cards, so a new writer sees what the roster is for.
     characters: [
@@ -349,7 +353,8 @@ export function normalizeState(value) {
   // Cards written before R25 have no length; a scene is about a page. Cards
   // written before R29 have no cast; nobody is in the scene until someone is.
   let patched = false;
-  const notes = value.notes.map((note) => {
+
+  const rawIds = new Set((value.notes ?? []).map((item) => item?.id).filter((id) => typeof id === "string"));  const notes = value.notes.map((note) => {
     const rank = note && NOTE_RANKS.includes(note.rank) ? note.rank : "scene";
     // Unsized stays unsized: null (or no field, before R25) claims nothing and
     // reads as about a page. A number is the writer's estimate, kept in range.
@@ -368,6 +373,8 @@ export function normalizeState(value) {
     const payoffNoteId = payoffBoardId && typeof note?.payoffNoteId === "string" && note.payoffNoteId ? note.payoffNoteId : null;
     // Cards written before R59 are not open; a card claims to be decided until the writer says otherwise.
     const open = typeof note?.open === "string" ? note.open : "";
+    // Cards written before R65 are versions of nothing; a version whose sibling is gone, or of itself, stands as a plain card.
+    const alternativeOf = typeof note?.alternativeOf === "string" && note.alternativeOf !== note?.id && rawIds.has(note.alternativeOf) ? note.alternativeOf : 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 R61's edge have no open place; a place is decided or blank until the writer says otherwise.
@@ -386,6 +393,7 @@ export function normalizeState(value) {
       sameIds(note.characterIds, characterIds) &&
       note.plants === plants &&
       note.plantsWhat === plantsWhat &&
+      note.alternativeOf === alternativeOf &&
       note.payoffBoardId === payoffBoardId &&
       note.payoffNoteId === payoffNoteId &&
       note.open === open &&
@@ -398,8 +406,17 @@ export function normalizeState(value) {
       return note;
     }
     patched = true;
-    return { ...note, rank, lengthEighths, characterIds, plants, plantsWhat, payoffBoardId, payoffNoteId, open, location, locationOpen, when, whenOpen, text };
+    return { ...note, rank, lengthEighths, characterIds, plants, plantsWhat, alternativeOf, payoffBoardId, payoffNoteId, open, location, locationOpen, when, whenOpen, text };
   });
+  // A version of a version is a version of the front card, so the pair stays a pair.
+  for (const [index, note] of notes.entries()) {
+    if (!note.alternativeOf) continue;
+    const front = notes.find((item) => item.id === note.alternativeOf);
+    if (front?.alternativeOf) {
+      patched = true;
+      notes[index] = { ...note, alternativeOf: front.alternativeOf === note.id ? null : front.alternativeOf };
+    }
+  }
 
   // Boards written before the production half (Roadmap 2, item 8) have no
   // lock and no revision; both are null until a draft goes out.
@@ -430,10 +447,13 @@ export function normalizeState(value) {
     .filter(Boolean);
   // Boards written before R61 have no open logline; a logline is decided or blank until the writer says otherwise.
   const loglineOpen = typeof value.loglineOpen === "string" ? value.loglineOpen : "";
+  // A target left open in the writer's words (the handover's calls, 2026-09-19): the number stands as the default meanwhile.
+  const targetOpen = typeof value.targetOpen === "string" ? value.targetOpen : "";
   if (
     value.logline === logline &&
     value.loglineOpen === loglineOpen &&
     value.targetEighths === targetEighths &&
+    value.targetOpen === targetOpen &&
     !rosterPatched &&
     !arrowsPatched &&
     !patched &&
@@ -449,6 +469,7 @@ export function normalizeState(value) {
     logline,
     loglineOpen,
     targetEighths,
+    targetOpen,
     characters,
     notes: patched ? notes : value.notes,
     arrows: arrowsPatched ? arrows : value.arrows,
@@ -491,6 +512,11 @@ function cleanOpen(value) {
 /** Cards within half a card's height of each other sit on one row. */
 const ROW_TOLERANCE = NOTE_HEIGHT / 2;
 
+/** A card that is another version of a card is not in the story (R65): not in the order, the count or the pages, until chosen. */
+export function inStory(note) {
+  return !note.alternativeOf;
+}
+
 export function readingOrder(notes) {
   const byTop = [...notes].sort((a, b) => a.y - b.y || a.x - b.x);
   const rows = [];
@@ -518,7 +544,7 @@ export function readingOrder(notes) {
  */
 export function storyOrder(state, ids) {
   const scope = ids ? new Set(ids) : null;
-  const notes = state.notes.filter((note) => !scope || scope.has(note.id));
+  const notes = state.notes.filter((note) => inStory(note) && (!scope || scope.has(note.id)));
   const reading = readingOrder(notes);
   const byId = new Map(reading.map((note) => [note.id, note]));
   const rank = new Map(reading.map((note, index) => [note.id, index]));
@@ -635,6 +661,7 @@ export function applyCommand(state, command, now = nowIso()) {
             ? null
             : clampEighths(command.lengthEighths, DEFAULT_NOTE_EIGHTHS, MAX_NOTE_EIGHTHS),
         characterIds: knownCast(command.characterIds, state.characters ?? []),
+        alternativeOf: null,
         plants: command.plants === true || Boolean(cleanOpen(command.plantsWhat)),
         // What it plants, in the writer's words (R62): naming a plant folds the card.
         plantsWhat: command.plants === false ? "" : cleanOpen(command.plantsWhat),
@@ -716,19 +743,14 @@ export function applyCommand(state, command, now = nowIso()) {
     }
 
     case "set_target": {
-      const targetEighths = clampEighths(
-        command.targetEighths,
-        DEFAULT_TARGET_EIGHTHS,
-        MAX_TARGET_EIGHTHS,
-      );
-      if (targetEighths === (state.targetEighths ?? DEFAULT_TARGET_EIGHTHS)) {
-        return { state, changed: false };
-      }
-      return {
-        state: { ...state, targetEighths },
-        changed: true,
-        result: { targetEighths },
-      };
+      // A number decides the target and clears the open words; open words
+      // leave the number where it is (the default, or the last one set) and
+      // say the writer has not decided; open "" takes the words back.
+      const hasOpen = typeof command.open === "string";
+      const targetOpen = hasOpen ? cleanOpen(command.open) : typeof command.targetEighths === "number" ? "" : (state.targetOpen ?? "");
+      const targetEighths = typeof command.targetEighths === "number" ? clampEighths(command.targetEighths, DEFAULT_TARGET_EIGHTHS, MAX_TARGET_EIGHTHS) : state.targetEighths;
+      if (targetEighths === state.targetEighths && targetOpen === (state.targetOpen ?? "")) return { state, changed: false };
+      return { state: { ...state, targetEighths, targetOpen }, changed: true, result: { targetEighths, targetOpen } };
     }
 
     case "set_rank": {
@@ -780,7 +802,7 @@ export function applyCommand(state, command, now = nowIso()) {
       const gone = state.notes.find((note) => note.id === command.id);
       if (!gone) return { state, changed: false };
       const headlineOf = (id) => state.notes.find((note) => note.id === id)?.headline ?? id;
-      const notes = state.notes.filter((note) => note.id !== command.id);
+      let notes = state.notes.filter((note) => note.id !== command.id);
       const taken = state.arrows.filter((arrow) => arrow.from === command.id || arrow.to === command.id);
       let arrows = state.arrows.filter((arrow) => !taken.includes(arrow));
       // A card wired into a chain — one follows in, one follows out — leaves
@@ -804,6 +826,8 @@ export function applyCommand(state, command, now = nowIso()) {
       );
       // A thread through the card keeps its name and loses the card (R60);
       // the thread stays, with one card fewer, so the writer can retie it.
+      // A version whose front card goes stands as a plain card (R65).
+      notes = notes.map((note) => (note.alternativeOf === command.id ? { ...note, alternativeOf: null } : note));
       const threadsLeft = [];
       const threads = (state.threads ?? []).map((thread) => {
         if (!thread.noteIds.includes(command.id)) return thread;
@@ -880,6 +904,60 @@ export function applyCommand(state, command, now = nowIso()) {
       return { state: { ...state, groups }, changed: true };
     }
 
+    // Two versions of one scene (R65): a card set behind another as its
+    // alternative leaves the story — the order, the count, the pages — and
+    // waits there until the writer chooses one. The reading lists the pair.
+    case "set_alternative": {
+      const note = state.notes.find((item) => item.id === command.id);
+      if (!note) return { state, changed: false };
+      const of = typeof command.of === "string" && command.of ? command.of : null;
+      if (of === null) {
+        if (!note.alternativeOf) return { state, changed: false };
+        const notes = state.notes.map((item) => (item.id === command.id ? bump(item, { alternativeOf: null }, now) : item));
+        return { state: { ...state, notes }, changed: true, result: { id: command.id, of: null, arrowsDropped: 0 } };
+      }
+      const front = state.notes.find((item) => item.id === of);
+      if (!front || of === command.id || front.alternativeOf || state.notes.some((item) => item.alternativeOf === command.id)) return { state, changed: false };
+      if (note.alternativeOf === of) return { state, changed: false };
+      // Out of the story: its follows arrows go with it; setup arrows are claims and stay.
+      const arrows = state.arrows.filter((arrow) => arrow.kind === "setup" || (arrow.from !== command.id && arrow.to !== command.id));
+      const notes = state.notes.map((item) => (item.id === command.id ? bump(item, { alternativeOf: of }, now) : item));
+      return { state: { ...state, notes, arrows }, changed: true, result: { id: command.id, of, arrowsDropped: state.arrows.length - arrows.length } };
+    }
+
+    // Choose one of two versions (R65): the chosen card is the scene, in the
+    // front card's place; the other goes, or stands beside it as a plain
+    // card when the writer says keep.
+    case "choose_version": {
+      const chosen = state.notes.find((item) => item.id === command.id);
+      if (!chosen) return { state, changed: false };
+      const other = chosen.alternativeOf ? state.notes.find((item) => item.id === chosen.alternativeOf) : state.notes.find((item) => item.alternativeOf === chosen.id);
+      if (!other) return { state, changed: false };
+      const frontId = chosen.alternativeOf ? other.id : chosen.id;
+      let notes = state.notes;
+      let arrows = state.arrows;
+      let groups = state.groups;
+      if (chosen.alternativeOf) {
+        // The alternative steps forward: the front's arrows, place in the order, rank and group are its now.
+        arrows = arrows.map((arrow) => ({ ...arrow, from: arrow.from === frontId ? chosen.id : arrow.from, to: arrow.to === frontId ? chosen.id : arrow.to })).filter((arrow) => arrow.from !== arrow.to);
+        groups = groups.map((group) => (group.noteIds.includes(frontId) ? { ...group, noteIds: group.noteIds.map((id) => (id === frontId ? chosen.id : id)) } : group));
+        notes = notes.map((item) => (item.id === chosen.id ? bump(item, { alternativeOf: null, x: other.x, y: other.y, rank: other.rank, z: other.z }, now) : item));
+      }
+      const keep = command.keep === true;
+      if (keep) {
+        notes = notes.map((item) => (item.id === other.id ? bump(item, { alternativeOf: null, x: item.x + 40, y: item.y + 40 }, now) : item));
+        if (chosen.alternativeOf) {
+          arrows = arrows.filter((arrow) => arrow.kind === "setup" || (arrow.from !== other.id && arrow.to !== other.id));
+          groups = groups.map((group) => (group.noteIds.includes(other.id) ? { ...group, noteIds: group.noteIds.filter((id) => id !== other.id) } : group));
+        }
+      } else {
+        notes = notes.filter((item) => item.id !== other.id);
+        arrows = arrows.filter((arrow) => arrow.from !== other.id && arrow.to !== other.id);
+        groups = pruneGroups(groups.map((group) => ({ ...group, noteIds: group.noteIds.filter((id) => id !== other.id) })));
+      }
+      return { state: { ...state, notes, arrows, groups }, changed: true, result: { chosen: chosen.id, other: other.id, kept: keep, steppedForward: Boolean(chosen.alternativeOf) } };
+    }
+
     // A thread (R60): a named string through cards, either end open until the
     // writer ties it. A record of its own beside the fold and the setup arrow;
     // the reading asks about each loose end from that end.
@@ -1167,6 +1245,7 @@ export function applyCommand(state, command, now = nowIso()) {
         characterIds: [],
         plants: false,
         plantsWhat: "",
+        alternativeOf: null,
         payoffBoardId: null,
         payoffNoteId: null,
         open: "",