plotcoder-board 0.1.28 → 0.1.30

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-two 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), `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. 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 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,11 +51,15 @@ 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. Eighteen rounds have been run, the first three through a
+just what produces it. Nineteen rounds have been run, the first three through a
 repo checkout and the rest through the account door; every finding from the
-first seventeen is fixed or decided, and round seventeen, the first to start from
+first seventeen is fixed or decided. Round seventeen, the first to start from
 a page of notes instead of a treatment, found the wall has no way to hold a
-maybe — the open card, R59, proposed and mocked from it. [`blind-runs/`](blind-runs/) holds the rules that keep a round honest,
+maybe — the open card, R59, built from it; round eighteen confirmed that a
+thread is not a fold — the thread, R60, built from it, a named string through
+cards with either end open until the writer ties it; round nineteen measured
+the thread and found the fold beside it cannot say which of two things a
+scene plants. [`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
@@ -100,4 +104,4 @@ next round into a test of `claim_account` instead of the door it meant to test.
 
 ## Status
 
-Version 0.1.28. 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.30. 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.28",
+  "version": "0.1.30",
   "type": "module",
   "scripts": {
     "dev": "vite",

package/scripts/plotcoder-mcp-server.mjs

@@ -856,6 +856,10 @@ function describeCommand(command) {
       return "recolor_note";
     case "apply_poses":
       return "organize";
+    case "create_thread":
+      return `create_thread "${command.name ?? ""}"`;
+    case "update_thread":
+      return typeof command.startOpen === "boolean" || typeof command.endOpen === "boolean" ? "update_thread (an end tied or opened)" : "update_thread";
     default:
       return command.type;
   }
@@ -968,7 +972,7 @@ function isSampleWall(state) {
   return state.notes.map((note) => note.headline).sort().join("\n") === sample;
 }
 /** Every check read_wall runs, so silence can be named. */
-const CHECKS = ["unmarked", "sag", "empty", "unwritten", "unlinked", "duplicate", "sequence", "uncast", "nobody", "absent", "backwards", "unpaid", "unplanted", "unplaced"];
+const CHECKS = ["unmarked", "sag", "empty", "unwritten", "unlinked", "duplicate", "sequence", "uncast", "nobody", "absent", "backwards", "unpaid", "unplanted", "unplaced", "loose"];
 /** What each check looks for, in words, so "clean" says what was checked rather than a kind's name. */
 const CHECK_WORDS = {
   unmarked: "a beat is marked",
@@ -985,6 +989,20 @@ const CHECK_WORDS = {
   unpaid: "no fold without a payoff",
   unplanted: "no payoff without its fold",
   unplaced: "no card without a place",
+  loose: "no thread with a loose end",
+};
+/** What an open card would be asked once closed, as the question and not the check's clean form (round nineteen, entry 31). */
+const ASK_WORDS = {
+  unwritten: "its change line",
+  unlinked: "what comes before and after it",
+  duplicate: "which of two alike headlines it is",
+  sequence: "whether its group is one sequence",
+  nobody: "who is in it",
+  absent: "who has been gone too long",
+  backwards: "why its payoff comes before its setup",
+  unpaid: "where its fold pays off",
+  unplanted: "what plants its payoff",
+  unplaced: "where it happens",
 };
 const SAMPLE_NOTE = "sample: this is the wall PlotCoder starts with (Maya, Tom, the letter); nothing here is the writer's. Replace it, or new_board.";
 
@@ -1046,7 +1064,7 @@ function summarize(state) {
       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 openWord = note.open ? `, open: ${note.open}` : "";
+      const openWord = note.open ? `, open (the writer's words): "${note.open}"` : "";
       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)}` : "";
@@ -1122,18 +1140,20 @@ function summarize(state) {
     `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 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)}`,
+      : `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)${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)",
     "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):",
+    "cast (the project's; every board of it casts from here; read_character reads a person's whole page, update_character writes it):",
     cast || "  (no one yet — add_character to start the roster)",
     "places (each phrase is its own place, and the app relates none of them — if two are one place, set_location them the same):",
     places || "  (no card says where it happens yet)",
     "groups:",
     groups || "  (no groups)",
+    "threads (a named string through cards, in story order; an open end is asked about by the reading):",
+    ...((state.threads ?? []).length ? state.threads.map((thread) => `  - ${threadLine(state, thread)}`) : ["  (no threads — create_thread names one)"]),
     "arrows:",
     arrows || "  (no arrows)",
   ].join("\n");
@@ -1380,7 +1400,8 @@ server.registerTool(
         }
       }
       // Wired into the story where the writer said, in the same frame.
-      if (beside && made?.id && wallHasFollows) {
+      // On a wall with no follows arrows yet, after or before draws the first one (round nineteen, entry 14).
+      if (beside && made?.id) {
         // Count the rewiring, so the reply can say it as move_scene does (round eighteen, entry 36).
         const run = (command) => {
           const done = step(command);
@@ -1406,9 +1427,7 @@ server.registerTool(
     ].filter(Boolean).join(", ");
     // Where it landed matters only until the tidy, so the reply says the rule once and never the coordinates (round fourteen, entry 11).
     const placed = beside
-      ? wallHasFollows
-        ? ` Wired ${args.after ? "after" : "before"} "${beside.headline}" in the story (${removedArrows} follows arrow${removedArrows === 1 ? "" : "s"} removed, ${drawnArrows} drawn)${joinedGroup ? `, in "${joinedGroup}"` : ""}, and the wall tidied.`
-        : ` The wall has no follows arrows, so "${args.after ? "after" : "before"}" has no story to land in: it sits after the last card; create_arrow the sequence, then move_scene.`
+      ? ` Wired ${args.after ? "after" : "before"} "${beside.headline}" in the story (${removedArrows} follows arrow${removedArrows === 1 ? "" : "s"} removed, ${drawnArrows} drawn${wallHasFollows ? "" : "; the wall's first, so the story order starts here"})${joinedGroup ? `, in "${joinedGroup}"` : ""}, and the wall tidied.`
       : args.x === undefined && args.y === undefined ? ` Placed after the last card in story order.${once("placed", " organize lays the wall out along the arrows.")}` : "";
     // Under a lock a new scene has a letter, not a number: say it, since the board is the only other place to learn it (round fourteen, entry 44).
     const numbered = after?.lock && result?.id ? ` Numbered ${sceneNumbers(storyOrder(after), after.lock).get(result.id)} (the numbers are locked; a new scene's letter is its place between locked ones now, worked out again from where it sits if it moves; the locked numbers never move).` : "";
@@ -1445,7 +1464,8 @@ server.registerTool(
       .map(([field, word]) => `${word}: "${prior?.[field] ?? ""}" → "${result[field] ?? ""}"`);
     if (!changed || fields.length === 0) return ok(`Nothing changed on "${result.headline}": the card already read that way.`);
     const mark = state.revision && state.revision.snapshot?.[result.id] && (state.revision.snapshot[result.id].headline !== result.headline || state.revision.snapshot[result.id].change !== result.change) ? ` Marked changed in the ${state.revision.color} revision "${state.revision.name}".` : "";
-    return ok(`Updated "${result.headline}" — ${fields.join("; ")}${where(live)}.${mark}`, result);
+    const placeNote = args.location !== undefined && (prior?.location ?? "") !== (result.location ?? "") ? nearPlaces(state, result.location) : "";
+    return ok(`Updated "${result.headline}" — ${fields.join("; ")}${where(live)}.${mark}${placeNote}`, result);
   },
 );
 
@@ -1551,7 +1571,7 @@ server.registerTool(
       "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 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"}  (${whose || "no cards"}; page_count is the script so far)`,
+        : `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)`,
       `groups: ${
         state.groups.length
           ? state.groups
@@ -1580,9 +1600,12 @@ server.registerTool(
       ...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`),
       ...(reading.open.length
-        ? ["open, by the writer's word (listed, not asked about while the words stand; set_open with \"\" closes):", ...reading.open.map((item) => `  - "${state.notes.find((note) => note.id === item.id)?.headline ?? item.id}" — ${item.words}${item.hides.length ? ` (would be asked, closed: ${item.hides.map((kind) => CHECK_WORDS[kind] ?? kind).join("; ")})` : ""}`)]
+        ? ["open, by the writer's word (listed, not asked about while the words stand; set_open with \"\" closes):", ...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.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" : ""}`)]
         : []),
-      "questions the wall raises:",
+      "questions the wall raises (each stands on every reading until the wall changes to answer it, or the writer leaves it — leave_question, with their reason):",
       ...(reading.findings.length
         ? reading.findings.map((finding) => `  - [${finding.kind}] ${finding.text}${finding.ids.length ? ` (ids: ${finding.ids.join(", ")})` : ""}`)
         : [reading.left.length ? "  (none the writer has not left)" : "  (none that this reading can see)"]),
@@ -2016,7 +2039,7 @@ server.registerTool(
     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}${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:`,
+      `"${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}, the page its last card ends on — read_wall counts the same cards as about ${formatPages(boardEighths(state))} pages${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:`,
       // On a wall under half its target the pairing is arithmetic; say so before the rows, not after them (round eighteen, entry 52).
       ...(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`] : []),
       ...describeComparison(comparison).map((line) => `  - ${line}`),
@@ -2941,7 +2964,7 @@ server.registerTool(
     });
     const total = parts.reduce((sum, part) => sum + part.on.length, 0);
     // An open card reads as open on a person's page too (round eighteen, entry 53).
-    const where_ = (note) => [note.location ? `at ${note.location}` : "", note.when ? note.when : "", note.rank === "beat" ? "beat" : "", note.open ? `open: ${note.open}` : ""].filter(Boolean).join(" · ");
+    const where_ = (note) => [note.location ? `at ${note.location}` : "", note.when ? note.when : "", note.rank === "beat" ? "beat" : "", note.open ? `open: "${note.open}"` : ""].filter(Boolean).join(" · ");
     // A read opens with the door it came through, like every reading (round sixteen, entry 28); one scene a line (29).
     const lines = [
       `PlotCoder cast (${door(live, base)})`,
@@ -2999,6 +3022,17 @@ server.registerTool(
   },
 );
 
+/** A near match on the wall is probably the same place spelled twice (round ten; update_note too, round nineteen entry 36). */
+function nearPlaces(state, place) {
+  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())),
+      )
+    : [];
+  return 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.` : "";
+}
+
 server.registerTool(
   "set_location",
   {
@@ -3019,16 +3053,8 @@ 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)}.${warn}${stillOpen(result)}`,
+      `${result.length} card(s) now ${place ? `at ${place}` : "nowhere"}${where(live)}.${nearPlaces(state, place)}${stillOpen(result)}`,
       result,
     );
   },
@@ -3106,6 +3132,126 @@ server.registerTool(
   },
 );
 
+// --- Threads (R60) ----------------------------------------------------------
+//
+// A thread is a named string through cards, either end open until the writer
+// ties it: the record for a thing the writer knows the far end of — the
+// bucket in the last scene, the key that changes hands — and not where it is
+// first seen. A fold and a setup arrow are still how a plant and its payoff
+// are drawn; a thread is beside them, in the writer's words, and the reading
+// asks about each loose end from that end.
+
+function threadByRef(state, ref) {
+  const wanted = (ref ?? "").trim();
+  if (!wanted) return null;
+  return (state.threads ?? []).find((thread) => thread.id === wanted) ?? (state.threads ?? []).find((thread) => thread.name.trim().toLowerCase() === wanted.toLowerCase()) ?? null;
+}
+
+function cardsByRef(state, refs) {
+  const found = [];
+  const missing = [];
+  for (const ref of refs ?? []) {
+    const wanted = (ref ?? "").trim();
+    const note = state.notes.find((item) => item.id === wanted) ?? state.notes.find((item) => item.headline.trim().toLowerCase() === wanted.toLowerCase()) ?? null;
+    if (note) found.push(note.id);
+    else missing.push(ref);
+  }
+  return { found, missing };
+}
+
+function threadLine(state, thread) {
+  const order = storyOrder(state).filter((note) => thread.noteIds.includes(note.id));
+  const cards = order.length ? order.map((note) => `"${note.headline}"`).join(" → ") : "no card yet";
+  const ends = [thread.startOpen ? "starts nowhere yet" : null, thread.endOpen ? "ends nowhere yet" : null].filter(Boolean);
+  return `"${thread.name}" (${thread.id}): ${cards}${ends.length ? ` — ${ends.join(", ")}` : order.length ? " — both ends tied" : ""}`;
+}
+
+server.registerTool(
+  "create_thread",
+  {
+    title: "Name a thread",
+    description:
+      "Name a thread — a thing that runs through the story and is first seen somewhere and comes out somewhere: \"the letter\", \"the shop's lease\", a subplot — and string it through the cards it touches, by id or headline, in story order. Say which end is not decided: startOpen when the writer knows where it comes out and not where it is first seen; endOpen when they know where it starts and not where it comes out. The reading asks about each open end from that end — \"where is it first seen?\" — until update_thread ties it, and lists every thread with its cards. A thread is beside the fold and the setup arrow, not instead of them: fold the card that plants and draw the setup arrow when both scenes exist; a thread is for the writer's word before they do, and for a strand a fold cannot hold. Only on the writer's word: a thread is theirs to name.",
+    inputSchema: {
+      name: z.string().min(1),
+      cards: z.array(z.string()).optional(),
+      startOpen: z.boolean().optional(),
+      endOpen: z.boolean().optional(),
+    },
+  },
+  async (args) => {
+    const current = await readBoard();
+    const { found, missing } = cardsByRef(current.state, args.cards);
+    if (missing.length) return ok(`No thread made: not on the board — ${missing.map((ref) => `"${ref}"`).join(", ")}. Call list_board for the ids or the exact headlines.`);
+    const { state, changed, result, live } = await commit({ type: "create_thread", name: args.name, noteIds: found, startOpen: args.startOpen === true, endOpen: args.endOpen === true });
+    if (!changed) return ok("No thread made: a thread needs a name.");
+    const asks = [result.startOpen ? "where it is first seen" : null, result.endOpen ? "where it comes out" : null].filter(Boolean);
+    return ok(
+      `Named the thread ${threadLine(state, result)}${where(live)}.${asks.length ? ` The reading asks ${asks.join(" and ")} until update_thread ties ${asks.length === 1 ? "that end" : "them"}.` : result.noteIds.length ? " Both ends are tied; the reading lists it and asks nothing." : " No card yet: the reading asks where it is first seen and where it comes out."} The wall draws it as a string through its cards, a loose end where one is open.`,
+      result,
+    );
+  },
+);
+
+server.registerTool(
+  "update_thread",
+  {
+    title: "Tie or change a thread",
+    description:
+      "Change a thread by id or name: rename it, add cards (by id or headline) or remove them, or tie an end — startOpen false once the writer says where it is first seen, endOpen false once they say where it comes out; true reopens an end. Adding the card where a thing is first seen and tying the start is one call: add plus startOpen false. The reading stops asking about an end the moment it is tied.",
+    inputSchema: {
+      thread: z.string(),
+      name: z.string().optional(),
+      add: z.array(z.string()).optional(),
+      remove: z.array(z.string()).optional(),
+      startOpen: z.boolean().optional(),
+      endOpen: z.boolean().optional(),
+    },
+  },
+  async (args) => {
+    const current = await readBoard();
+    const thread = threadByRef(current.state, args.thread);
+    if (!thread) return ok(`No thread called "${args.thread}". list_board names the threads on this board; create_thread names a new one.`);
+    const add = cardsByRef(current.state, args.add);
+    const remove = cardsByRef(current.state, args.remove);
+    const missing = [...add.missing, ...remove.missing];
+    if (missing.length) return ok(`Nothing changed: not on the board — ${missing.map((ref) => `"${ref}"`).join(", ")}. Call list_board for the ids or the exact headlines.`);
+    const { state, changed, result, live } = await commit({
+      type: "update_thread",
+      id: thread.id,
+      ...(args.name !== undefined ? { name: args.name } : {}),
+      ...(add.found.length ? { add: add.found } : {}),
+      ...(remove.found.length ? { remove: remove.found } : {}),
+      ...(typeof args.startOpen === "boolean" ? { startOpen: args.startOpen } : {}),
+      ...(typeof args.endOpen === "boolean" ? { endOpen: args.endOpen } : {}),
+    });
+    if (!changed) return ok(`Nothing changed: "${thread.name}" already reads that way.`);
+    const tied = [result.before.startOpen && !result.thread.startOpen ? "its start" : null, result.before.endOpen && !result.thread.endOpen ? "its end" : null].filter(Boolean);
+    const reopened = [!result.before.startOpen && result.thread.startOpen ? "its start" : null, !result.before.endOpen && result.thread.endOpen ? "its end" : null].filter(Boolean);
+    return ok(
+      `Now ${threadLine(state, result.thread)}${where(live)}.${tied.length ? ` Tied ${tied.join(" and ")}; the reading stops asking about ${tied.length === 1 ? "it" : "them"}.` : ""}${reopened.length ? ` Opened ${reopened.join(" and ")}; the reading asks about ${reopened.length === 1 ? "it" : "them"} again.` : ""}`,
+      result.thread,
+    );
+  },
+);
+
+server.registerTool(
+  "delete_thread",
+  {
+    title: "Cut a thread",
+    description: "Remove a thread by id or name. The cards stay; only the string and its name go. Only on the writer's word.",
+    inputSchema: { thread: z.string() },
+  },
+  async (args) => {
+    const current = await readBoard();
+    const thread = threadByRef(current.state, args.thread);
+    if (!thread) return ok(`No thread called "${args.thread}". list_board names the threads on this board.`);
+    const { changed, result, live } = await commit({ type: "delete_thread", id: thread.id });
+    if (!changed) return ok(`No thread called "${args.thread}".`);
+    return ok(`Cut the thread "${result.name}"${where(live)}; its ${result.noteIds.length} card${result.noteIds.length === 1 ? "" : "s"} stay where they are.`, result);
+  },
+);
+
 // --- Groups -----------------------------------------------------------
 
 server.registerTool(
@@ -3650,7 +3796,7 @@ server.registerTool(
   {
     title: "Save the project as a file",
     description:
-      "The project the server is working, as the file Save project writes and Open project takes: the record, every board with its cards, the reminders and the writer's structures. Pass path to write it (a .json) — an absolute path, since a relative one resolves from the folder the server was started in, not yours; without a path, the reply's JSON is the file. Pictures and takes on the account are not in the file. Works through every door.",
+      `The project the server is working, as the file Save project writes and Open project takes: the record, every board with its cards, the reminders and the writer's structures. Pass path to write it (a .json) — an absolute path, since a relative one resolves from the folder the server was started in, which is ${process.cwd()}, not yours; without a path, the reply's JSON is the file. Pictures and takes on the account are not in the file. Works through every door.`,
     inputSchema: { path: z.string().optional() },
   },
   async (args) => {

package/src/board/agents.js

@@ -55,7 +55,7 @@ export const AGENTS = {
     "No opinions about how many beats there should be. Marking the turns a treatment plainly makes is reading it, not an opinion: mark them, say which, and let the writer strike or add.",
     "Page counts are estimates.",
     "Ask before delete_board, delete_project, empty_account, delete_account, unlock_numbers, remove_file, an import_project that replaces, or claim_account — the writer gives the email and the password; never invent one. export_project first, when something might be wanted back.",
-    "Do not invent people or a logline. What the treatment states — an age, a job, a bad knee — is not invented: it goes in the person's notes. An unnamed person is named by their role — Dana's mother, the dispatcher — which is a name until the writer gives one. A scene is one place and one stretch of time; a new place or time is a new card. A beat is a whole card; a setup arrow lands on the scene's card, so a payoff never needs a card of its own. Acts are groups titled Act one, Act two, when the treatment has them; the wall never asks whether an act is a sequence. Paper colour means nothing to the app. Under target is a fact to report plainly, like over; neither is a verdict.",
+    "Do not invent people or a logline. What the treatment states — an age, a job, a bad knee — is not invented: it goes in the person's notes. An unnamed person is named by their role — Dana's mother, the dispatcher — which is a name until the writer gives one. A scene is one place and one stretch of time; a new place or time is a new card. A beat is a whole card; a setup arrow lands on the scene's card, so a payoff never needs a card of its own. Acts are groups titled Act one, Act two, when the treatment has them; the wall never asks whether an act is a sequence. Paper colour means nothing to the app. Under target is a fact to report plainly, like over; neither is a verdict. A thing the writer has not decided is an open card in their words (set_open), never a guess to fill the field; a thing whose far end the writer knows and not where it is first seen — the letter, the ring — is a thread (create_thread) with an open start, and the wall asks from that end.",
   ],
   person:
     "Give your agent the account door only on a machine you trust; it signs in as you and shows under People as “an agent, as you” while it runs. Wire the server before you start the agent's session, with the two sign-in lines beside it, and the agent has every tool from its first message; wired from inside a session, the server connects only on the next one. Your agent can also make your account: give it your email and a password of your choosing.",
@@ -68,7 +68,7 @@ export function agentsAsText() {
   // 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"];
+  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.`, "", "## Call these first"];
   AGENTS.first.forEach((item, index) => lines.push(`${index + 1}. ${item.tool} — ${item.why}`));
   lines.push("", AGENTS.firstNote);
   lines.push("", "## Rules");

package/src/board/fountain.js

@@ -124,6 +124,8 @@ export function toFountain(state, options = {}) {
     if (cast.length) marks.push(`with ${cast.join(", ")}`);
     if (note.plants) marks.push("plants something to pay off later");
     if (note.open) marks.push(`open: ${note.open}`);
+    const onThreads = (state.threads ?? []).filter((thread) => thread.noteIds.includes(note.id)).map((thread) => thread.name);
+    if (onThreads.length) marks.push(`thread: ${onThreads.join(", ")}`);
     if (revisionMarksFor(marks, note)) marks.push(`changed in the ${state.revision.color} revision`);
     if (marks.length) {
       body.push(`[[${marks.join(" · ")}]]`);

package/src/board/readWall.d.ts

@@ -33,11 +33,13 @@ export type FindingKind =
   /** A setup arrow whose payoff comes before its setup on the wall. */
   | "backwards"
   /** A card with a folded corner and no setup arrow leaving it. */
-  | "unpaid";
+  | "unpaid"
+  /** A thread (R60) with an end the writer has not tied: where it is first seen, or where it comes out. */
+  | "loose";
 
 export type Finding = {
   kind: FindingKind;
-  /** Card ids; a group id for "sequence"; a character id (then card ids) for "uncast" and "absent"; an arrow id (then card ids) for "backwards". Empty for "unmarked". */
+  /** Card ids; a group id for "sequence"; a character id (then card ids) for "uncast" and "absent"; an arrow id (then card ids) for "backwards"; a thread id (then card ids) for "loose". Empty for "unmarked". */
   ids: string[];
   /** The question, written for a writer. */
   text: string;
@@ -69,6 +71,8 @@ export type WallReading = {
   later: { id: string; boardId: string; noteId: string | null }[];
   /** Open cards (R59): the writer's words for what is not decided, in story order; not asked about while they stand. */
   open: Array<{ id: string; words: string; hides: FindingKind[] }>;
+  /** 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 }>;
   /** 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. */

package/src/board/readWall.js

@@ -502,6 +502,30 @@ export function readWall(state, options = {}) {
     }
   }
 
+  // Threads (R60): a named string through cards, in story order, either end
+  // open until the writer ties it. The reading asks about each loose end from
+  // that end — the question a fold cannot ask, where a thing is first seen.
+  const threads = (state.threads ?? []).map((thread) => ({
+    id: thread.id,
+    name: thread.name,
+    ids: order.filter((note) => thread.noteIds.includes(note.id)).map((note) => note.id),
+    startOpen: thread.startOpen === true,
+    endOpen: thread.endOpen === true,
+  }));
+  for (const thread of threads) {
+    const first = thread.ids.length ? byId.get(thread.ids[0]) : null;
+    const last = thread.ids.length ? byId.get(thread.ids[thread.ids.length - 1]) : null;
+    if (!thread.ids.length) {
+      findings.push({ kind: "loose", ids: [thread.id], text: `"${thread.name}" runs through no card yet. Where is it first seen, and where does it come out?` });
+    } else if (thread.startOpen && thread.endOpen) {
+      findings.push({ kind: "loose", ids: [thread.id, ...thread.ids], text: `"${thread.name}" runs through ${list(thread.ids.map((id) => byId.get(id)))} and neither end is tied. Where is it first seen, and where does it come out?` });
+    } else if (thread.startOpen) {
+      findings.push({ kind: "loose", ids: [thread.id, first.id], text: `"${thread.name}" starts nowhere yet: it runs ${thread.ids.length === 1 ? "to" : "through"} ${list(thread.ids.map((id) => byId.get(id)))}. Where is it first seen?` });
+    } else if (thread.endOpen) {
+      findings.push({ kind: "loose", ids: [thread.id, last.id], text: `"${thread.name}" ends nowhere yet: it runs ${thread.ids.length === 1 ? "from" : "through"} ${list(thread.ids.map((id) => byId.get(id)))}. Where does it come out?` });
+    }
+  }
+
   // A question the writer has left (R53) is held back while it is still the
   // same question — same kind, same cards, same words. The moment it would
   // read differently (a page moved, a headline changed, the median shifted)
@@ -509,7 +533,11 @@ export function readWall(state, options = {}) {
   // reading does, on every read.
   const left = [];
   // A question whose every card is open is not asked (R59): the writer's word covers it.
-  const openCards = openIds.size ? findings.filter((finding) => finding.ids.some((id) => byId.has(id)) && finding.ids.filter((id) => byId.has(id)).every((id) => openIds.has(id))) : [];
+  // Not so for a question about the story around the card: a thread's loose end
+  // (R60) is the writer's own claim, and the run's questions — beats back to
+  // back, a sag — are about the cards between, as the guide promises (round
+  // nineteen, entry 28). Those are asked whether or not the cards are open.
+  const openCards = openIds.size ? findings.filter((finding) => !ASKED_OF_OPEN_CARDS.has(finding.kind) && finding.ids.some((id) => byId.has(id)) && finding.ids.filter((id) => byId.has(id)).every((id) => openIds.has(id))) : [];
   const asked = findings.filter((finding) => {
     if (openCards.includes(finding)) return false;
     const entry = (state.left ?? []).find(
@@ -529,6 +557,7 @@ export function readWall(state, options = {}) {
     later,
     paidBy: paidHere,
     open: describeOpen(state, options, order, openIds),
+    threads,
     findings: asked,
     left,
   };
@@ -539,13 +568,19 @@ export function readWall(state, options = {}) {
  * closed (round eighteen, entry 27): the reading of the same wall with the
  * words cleared, read once more, so the writer can see what the words hide.
  */
+/** The question kinds an open card does not silence: about the story around it, not the card (R59, R60). */
+const ASKED_OF_OPEN_CARDS = new Set(["loose", "empty", "sag"]);
+
 function describeOpen(state, options, order, openIds) {
   if (!openIds.size) return [];
   const hides = new Map();
   if (!options.closedReading) {
     const closed = { ...state, notes: state.notes.map((note) => (openIds.has(note.id) ? { ...note, open: "" } : note)) };
     const again = readWall(closed, { ...options, closedReading: true });
-    for (const finding of again.findings) for (const id of finding.ids) if (openIds.has(id)) (hides.get(id) ?? hides.set(id, new Set()).get(id)).add(finding.kind);
+    // A question about the story around the card is asked whether or not the
+    // card is open, so it is never something the open words hide (round
+    // nineteen, entries 23 and 28).
+    for (const finding of again.findings) if (!ASKED_OF_OPEN_CARDS.has(finding.kind)) for (const id of finding.ids) if (openIds.has(id)) (hides.get(id) ?? hides.set(id, new Set()).get(id)).add(finding.kind);
   }
   return order.filter((note) => openIds.has(note.id)).map((note) => ({ id: note.id, words: note.open.trim(), hides: [...(hides.get(note.id) ?? [])] }));
 }

package/src/board/reducer.d.ts

@@ -118,6 +118,8 @@ export type BoardState = {
   characters: BoardCharacter[];
   notes: BoardNote[];
   groups: BoardGroup[];
+  /** Threads (R60): named strings through cards, either end open until tied. */
+  threads: BoardThread[];
   arrows: BoardArrow[];
   /** Locked scene numbers, once a draft has gone out (Roadmap 2, item 8); null until then. */
   lock: import("./numbering").Lock | null;
@@ -127,6 +129,17 @@ export type BoardState = {
   left: LeftQuestion[];
 };
 
+/** A thread (R60): a name, the cards it runs through, and whether either end is still open. */
+export type BoardThread = {
+  id: string;
+  name: string;
+  noteIds: string[];
+  /** Where it is first seen is not decided. */
+  startOpen: boolean;
+  /** Where it comes out is not decided. */
+  endOpen: boolean;
+};
+
 /** A question the wall asked and the writer left (R53). */
 export type LeftQuestion = {
   kind: string;
@@ -179,6 +192,9 @@ export type Command =
   | { type: "ungroup"; id: string }
   | { type: "add_to_group"; id: string; noteIds: string[] }
   | { type: "rename_group"; id: string; title: string }
+  | { type: "create_thread"; name: string; noteIds?: string[]; startOpen?: boolean; endOpen?: boolean; id?: string }
+  | { type: "update_thread"; id: string; name?: string; noteIds?: string[]; add?: string[]; remove?: string[]; startOpen?: boolean; endOpen?: boolean }
+  | { type: "delete_thread"; id: string }
   | { type: "create_arrow"; from: string; to: string; kind?: ArrowKind }
   | { type: "delete_arrow"; id: string }
   | { type: "set_arrow_kind"; id: string; kind: ArrowKind }

package/src/board/reducer.js

@@ -223,6 +223,7 @@ export function emptyState() {
     characters: [],
     notes: [],
     groups: [],
+    threads: [],
     arrows: [],
     lock: null,
     revision: null,
@@ -277,6 +278,7 @@ export function seedState(now = nowIso()) {
       mk("letter-aloud", "The letter is read aloud", "The plan dies in the room.", "blue", 196, 340, 0.8, 3, ["maya", "tom"]),
     ],
     groups: [],
+    threads: [],
     arrows: [],
     lock: null,
     revision: null,
@@ -390,6 +392,25 @@ export function normalizeState(value) {
   // the writer leaves it.
   const left = Array.isArray(value.left) ? value.left.filter(isLeftQuestion) : [];
   const leftPatched = !Array.isArray(value.left) || left.length !== value.left.length;
+  // Boards written before R60 have no threads: a wall has none until the
+  // writer names one. A thread that names a card the board no longer holds
+  // drops that card; a thread with no name is not a thread.
+  const noteIdSet = new Set(notes.map((note) => note.id));
+  let threadsPatched = !Array.isArray(value.threads);
+  const threads = (Array.isArray(value.threads) ? value.threads : [])
+    .map((thread) => {
+      if (!thread || typeof thread !== "object" || typeof thread.id !== "string" || typeof thread.name !== "string" || !thread.name.trim()) {
+        threadsPatched = true;
+        return null;
+      }
+      const noteIds = Array.isArray(thread.noteIds) ? thread.noteIds.filter((id, index) => typeof id === "string" && noteIdSet.has(id) && thread.noteIds.indexOf(id) === index) : [];
+      const startOpen = thread.startOpen === true;
+      const endOpen = thread.endOpen === true;
+      if (Array.isArray(thread.noteIds) && noteIds.length === thread.noteIds.length && thread.startOpen === startOpen && thread.endOpen === endOpen) return thread;
+      threadsPatched = true;
+      return { ...thread, noteIds, startOpen, endOpen };
+    })
+    .filter(Boolean);
   if (
     value.logline === logline &&
     value.targetEighths === targetEighths &&
@@ -398,7 +419,8 @@ export function normalizeState(value) {
     !patched &&
     value.lock === lock &&
     value.revision === revision &&
-    !leftPatched
+    !leftPatched &&
+    !threadsPatched
   ) {
     return value;
   }
@@ -412,6 +434,7 @@ export function normalizeState(value) {
     lock,
     revision,
     left,
+    threads,
   };
 }
 
@@ -435,6 +458,11 @@ function cleanOpen(value) {
   return typeof value === "string" ? value.trim().replace(/\s+/g, " ") : "";
 }
 
+/** A thread's name as the writer typed it, one line, spaces collapsed (R60). */
+function cleanThreadName(value) {
+  return typeof value === "string" ? value.trim().replace(/\s+/g, " ") : "";
+}
+
 /** A when as the writer typed it, one line, spaces collapsed. */
 function cleanWhen(value) {
   return typeof value === "string" ? value.trim().replace(/\s+/g, " ") : "";
@@ -631,10 +659,19 @@ export function applyCommand(state, command, now = nowIso()) {
           return { ...group, noteIds };
         }),
       );
+      // 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.
+      const threadsLeft = [];
+      const threads = (state.threads ?? []).map((thread) => {
+        if (!thread.noteIds.includes(command.id)) return thread;
+        const noteIds = thread.noteIds.filter((id) => id !== command.id);
+        threadsLeft.push({ id: thread.id, name: thread.name, remaining: noteIds.length });
+        return { ...thread, noteIds };
+      });
       // The result says what went with the card, so a door can say it too
       // (round thirteen, entry 17: "Deleted card." and nothing of the arrows).
       return {
-        state: { ...state, notes, arrows, groups },
+        state: { ...state, notes, arrows, groups, threads },
         changed: true,
         result: {
           id: command.id,
@@ -647,6 +684,7 @@ export function applyCommand(state, command, now = nowIso()) {
           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,
+          threads: threadsLeft,
         },
       };
     }
@@ -699,6 +737,50 @@ export function applyCommand(state, command, now = nowIso()) {
       return { state: { ...state, groups }, changed: true };
     }
 
+    // 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.
+    case "create_thread": {
+      const name = cleanThreadName(command.name);
+      if (!name) return { state, changed: false };
+      const noteIds = (command.noteIds ?? []).filter((id, index, all) => all.indexOf(id) === index && state.notes.some((note) => note.id === id));
+      const thread = {
+        id: typeof command.id === "string" && command.id && !(state.threads ?? []).some((item) => item.id === command.id) ? command.id : newId(),
+        name,
+        noteIds,
+        startOpen: command.startOpen === true,
+        endOpen: command.endOpen === true,
+      };
+      return { state: { ...state, threads: [...(state.threads ?? []), thread] }, changed: true, result: thread };
+    }
+
+    case "update_thread": {
+      const current = (state.threads ?? []).find((thread) => thread.id === command.id);
+      if (!current) return { state, changed: false };
+      const exists = (id) => state.notes.some((note) => note.id === id);
+      let noteIds = Array.isArray(command.noteIds) ? command.noteIds.filter((id, index, all) => all.indexOf(id) === index && exists(id)) : [...current.noteIds];
+      if (Array.isArray(command.add)) for (const id of command.add) if (exists(id) && !noteIds.includes(id)) noteIds.push(id);
+      if (Array.isArray(command.remove)) noteIds = noteIds.filter((id) => !command.remove.includes(id));
+      const name = command.name === undefined ? current.name : cleanThreadName(command.name) || current.name;
+      const startOpen = typeof command.startOpen === "boolean" ? command.startOpen : current.startOpen;
+      const endOpen = typeof command.endOpen === "boolean" ? command.endOpen : current.endOpen;
+      if (name === current.name && startOpen === current.startOpen && endOpen === current.endOpen && sameIds(noteIds, current.noteIds) && noteIds.length === current.noteIds.length) {
+        return { state, changed: false };
+      }
+      const next = { ...current, name, noteIds, startOpen, endOpen };
+      return {
+        state: { ...state, threads: state.threads.map((thread) => (thread.id === command.id ? next : thread)) },
+        changed: true,
+        result: { thread: next, before: current },
+      };
+    }
+
+    case "delete_thread": {
+      const gone = (state.threads ?? []).find((thread) => thread.id === command.id);
+      if (!gone) return { state, changed: false };
+      return { state: { ...state, threads: state.threads.filter((thread) => thread.id !== command.id) }, changed: true, result: gone };
+    }
+
     case "create_group": {
       const noteIds = command.noteIds.filter((id) =>
         state.notes.some((note) => note.id === id),

package/src/board/words.js

@@ -68,6 +68,11 @@ export const WORD_GROUPS = [
         name: "Open",
         sentence: "A card the writer has not decided, in their words on its edge: the reading lists it and asks nothing else of it until the words are cleared.",
       },
+      {
+        id: "thread",
+        name: "A thread",
+        sentence: "A named string through the cards a thing runs through — the letter, the key, a subplot — with either end open until the writer ties it. Drawn on the wall as a dashed string, a ring where an end is loose; the reading asks where a loose thread is first seen, or where it comes out.",
+      },
       {
         id: "corner",
         name: "The folded corner",

package/src/board/workflows.js

@@ -15,7 +15,7 @@ export const WORKFLOWS = [
     id: "break-a-treatment",
     name: "Break a treatment into a wall",
     ask: "Here is a treatment. Break it into a wall: one card per scene with a headline and what changes, the cast on each card, the places, and the major turns marked as beats.",
-    tools: ["list_words", "read_wall", "list_reminders", "list_board", "new_project", "new_board", "rename_project", "rename_board", "set_target", "set_logline", "set_premise", "create_note", "add_character", "cast", "update_character", "set_location", "set_when", "set_rank", "set_length", "set_plant", "create_arrow", "create_group", "organize"],
+    tools: ["list_words", "read_wall", "list_reminders", "list_board", "new_project", "new_board", "rename_project", "rename_board", "set_target", "set_logline", "set_premise", "create_note", "add_character", "cast", "update_character", "set_location", "set_when", "set_rank", "set_length", "set_plant", "create_thread", "create_arrow", "create_group", "organize"],
     then: "Start where the wall will live: on the account, new_project names it; in a folder, new_board for the writer's wall, then rename_project. Read the wall (read_wall) and say what it asks. A treatment is cards, one create_note each, with characters, location, rank and plants on the call; import_fountain is the door for pages, not a treatment — a scene's text measures its card.",
     // What a treatment should say (R49): eleven blind runs asked the writer
     // the same questions at the end of every build. Each is a fact the wall
@@ -25,12 +25,12 @@ export const WORKFLOWS = [
     needs: [
       { question: "How long is it?", hint: "An hour, a half-hour, a feature — or a page count, if you have one.", tool: "set_target" },
       { question: "What is the central question, in one sentence?", hint: "And if this is one episode of something, what is the series about?", tool: "set_logline, set_premise" },
-      { question: "Which scenes are the turns?", hint: "Name them, or say \"propose them and I will strike\".", tool: "set_rank" },
+      { question: "Which scenes are the turns?", hint: "Name them, say \"propose them and I will strike\", or say \"mark none yet\" — every card stays a scene and the reading asks once for a beat until you do.", tool: "set_rank" },
       { question: "Does it have acts?", hint: "If so, where does each break fall?", tool: "create_group" },
       { question: "Where does each scene happen?", hint: "In your own words. A scene that moves through one location is still one place.", tool: "set_location" },
       { question: "When does a scene happen, where that matters?", hint: "That night; the fourth of October. It goes beside the place, never in the headline.", tool: "set_when" },
       { question: "Who is in each scene, and what do we call them?", hint: "A full name, or a role for someone unnamed — the man in 42. And who is only spoken of, never in a scene? They go in someone's notes, not the cast.", tool: "add_character, cast, update_character" },
-      { question: "What is planted, and where does it pay off?", hint: "Name the episode when it pays off outside this one, so the fold is deliberate and the wall knows where to look.", tool: "set_plant with later, create_arrow" },
+      { question: "What is planted, and where does it pay off?", hint: "Name the episode when it pays off outside this one, so the fold is deliberate and the wall knows where to look. A thing whose far end you know and not its first sighting — the key, the bucket — is a thread with an open start.", tool: "set_plant with later, create_arrow; create_thread" },
       { question: "Which scenes do you already know run long or short?", hint: "A day in the story is not a page count; leave the rest unsized.", tool: "set_length" },
       { question: "What are the project and the board called?", hint: "The series, and this episode.", tool: "rename_project, rename_board" },
       { question: "What must not be invented?", hint: "Looks and voices are yours until you say; so is anything the treatment does not state.", tool: "update_character, later" },