plotcoder-board 0.1.33 → 0.1.35

package/README.md

@@ -51,7 +51,7 @@ 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. Nineteen rounds have been run, the first three through a
+just what produces it. Twenty 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. Round seventeen, the first to start from
 a page of notes instead of a treatment, found the wall has no way to hold a
@@ -59,7 +59,8 @@ 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,
+scene plants — the open field, R61, and the fold's words, R62, built from it,
+and round twenty measured both. [`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
@@ -104,4 +105,4 @@ next round into a test of `claim_account` instead of the door it meant to test.
 
 ## Status
 
-Version 0.1.33. 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.35. 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.33",
+  "version": "0.1.35",
   "type": "module",
   "scripts": {
     "dev": "vite",

package/scripts/plotcoder-mcp-server.mjs

@@ -71,6 +71,7 @@ import {
   setPremise,
   setPremiseOpen,
   setBoardNameOpen,
+  setProjectNameOpen,
   structureBeats,
   reidentifyProject,
   renameProject,
@@ -995,16 +996,16 @@ const CHECK_WORDS = {
 };
 /** 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",
+  unwritten: "its change line (update_note)",
+  unlinked: "what comes before and after it (move_scene, or create_arrow)",
+  duplicate: "which of two alike headlines it is (update_note)",
   sequence: "whether its group is one sequence",
-  nobody: "who is in it",
+  nobody: "who is in it (cast)",
   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",
+  unpaid: "where its fold pays off (create_arrow, kind setup)",
+  unplanted: "what plants its payoff (set_plant on the card that does)",
+  unplaced: "where it happens (set_location)",
 };
 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.";
 
@@ -1065,7 +1066,7 @@ function summarize(state) {
       const pays = paidByHere.filter((item) => item.id === note.id).map((item) => `, pays off "${item.fromHeadline}" from "${item.fromBoardName}" (${episodeLabel(lastHeld.project, lastHeld.boards, item.fromBoardId, item.fromNoteId)})`).join("");
       const snap = state.revision?.snapshot?.[note.id];
       const revised = snap && (snap.headline !== note.headline || snap.change !== note.change || (snap.text ?? "") !== (note.text ?? "") || (snap.location ?? "") !== (note.location ?? "")) ? `, changed in ${state.revision.color}` : "";
-      const place = note.location ? `, at: ${note.location}` : "";
+      const place = note.location ? `, at: ${note.location}` : note.locationOpen ? `, at: open, by the writer's word — "${note.locationOpen}"` : "";
       const when = note.when ? `, when: ${note.when}` : note.whenOpen ? `, when: open, by the writer's word — "${note.whenOpen}"` : "";
       const openWord = note.open ? `, open (the writer's words): "${note.open}"` : "";
       const count = formatPages(noteEighths(note));
@@ -1143,7 +1144,7 @@ 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 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)}`,
+      : `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)}`,
     `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)",
@@ -1344,7 +1345,8 @@ server.registerTool(
       rank: rankSchema.optional(),
       pages: pagesSchema.optional(),
       plants: z.boolean().optional(),
-      after: z.string().optional().describe("Wire the new scene into the story after this card (id or headline): one call, one number under a lock. Needs follows arrows on the wall."),
+      plantsWhat: z.string().optional(),
+      after: z.string().optional().describe("Wire the new scene into the story after this card (id or headline): one call, one number under a lock. On a wall with no follows arrows yet this draws the first, so a wall can be built in order from its second card."),
       before: z.string().optional().describe("Or before this card (id or headline)."),
       location: z.string().optional(),
       when: z.string().optional().describe('When the scene happens, as the writer says it — "night", "day four, dawn" — printed after the place on the scene heading.'),
@@ -1575,21 +1577,38 @@ server.registerTool(
     const beatEighths = reading.beats.reduce((sum, beat) => sum + noteEighths(state.notes.find((note) => note.id === beat.id) ?? {}), 0);
     // 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}`] : []),
       ...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}`] : []),
-      ...reading.openFields.filter((field) => field.field === "when").map((field) => `  - "${state.notes.find((note) => note.id === field.id)?.headline ?? field.id}" — when: ${field.words}`),
+      ...reading.openFields.filter((field) => field.field === "location").map((field) => `  - "${state.notes.find((note) => note.id === field.id)?.headline ?? field.id}" — where: ${field.words}`),
+      // Whens left open in the same words are one line, not one per card (round twenty, entry 22).
+      ...(() => {
+        const byWords = new Map();
+        for (const field of reading.openFields.filter((item) => item.field === "when")) {
+          const key = field.words.toLowerCase();
+          if (!byWords.has(key)) byWords.set(key, { words: field.words, ids: [] });
+          byWords.get(key).ids.push(field.id);
+        }
+        const name = (id) => `"${state.notes.find((note) => note.id === id)?.headline ?? id}"`;
+        return [...byWords.values()].map((group) =>
+          group.ids.length === 1
+            ? `  - ${name(group.ids[0])} — when: ${group.words}`
+            : `  - when, on ${group.ids.length} cards${group.ids.length === state.notes.length ? " (every card)" : ""} — ${group.words}${group.ids.length === state.notes.length ? "" : `: ${group.ids.map(name).join(", ")}`}`,
+        );
+      })(),
     ];
     const lines = [
       `PlotCoder wall (${door(live, base)})`,
       ...(state.lock ? [`numbers: locked since ${String(state.lock.at).slice(0, 10)}; read_pages shows each scene's number`] : []),
       `board: "${readBoardMeta?.name ?? "?"}"${readBoardMeta?.nameOpen ? ` — its name is open, by the writer's word: "${readBoardMeta.nameOpen}"` : ""}${projectForRead.boards.length > 1 ? ` — board ${projectForRead.boards.findIndex((meta) => meta.id === readBoardMeta?.id) + 1} of ${projectForRead.boards.length} in the project "${projectForRead.name}"; open_board reads another` : ""}`,
+      ...(projectForRead.nameOpen ? [`project: "${projectForRead.name}" — its name is open, by the writer's word: "${projectForRead.nameOpen}"`] : []),
       ...(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)`,
+        : `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
@@ -1621,7 +1640,7 @@ server.registerTool(
         ? ["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.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" : ""}`)]
+        ? ["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` : ""}`)]
         : []),
       "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
@@ -2024,11 +2043,15 @@ server.registerTool(
   async () => {
     const { project } = await readProject();
     const own = project.structures ?? [];
+    // Pages beside the percentages, against the open board's target, so the two readings agree without arithmetic (round twenty, entry 57).
+    const { state } = await readBoard();
+    const target = state?.targetEighths ?? DEFAULT_TARGET_EIGHTHS;
+    const at = (beat) => `${beat.name} at ${Math.round(beat.at * 100)}% (p. ${Math.floor((beat.at * target) / EIGHTHS_PER_PAGE) + 1})`;
     const lines = [
       `the writer's own: ${own.length}`,
-      ...own.map((structure) => `  - ${structure.id} — "${structure.name}" (${structure.beats.length} beats: ${structure.beats.map((beat) => `${beat.name} at ${Math.round(beat.at * 100)}%`).join(", ")})`),
+      ...own.map((structure) => `  - ${structure.id} — "${structure.name}" (${structure.beats.length} beats: ${structure.beats.map(at).join(", ")})`),
       `built in: ${TEMPLATES.length}`,
-      ...TEMPLATES.map((template) => `  - ${template.id} — "${template.name}" (${template.beats.length} beats: ${template.beats.map((beat) => `${beat.name} at ${Math.round(beat.at * 100)}%`).join(", ")})`),
+      ...TEMPLATES.map((template) => `  - ${template.id} — "${template.name}" (${template.beats.length} beats: ${template.beats.map(at).join(", ")})`),
       "compare_structure sets one of these beside this wall's beats, page by page, and lays nothing",
     ];
     return ok(lines.join("\n"), { builtIn: TEMPLATES.map((template) => ({ id: template.id, name: template.name, beats: template.beats })), own });
@@ -2057,10 +2080,11 @@ 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}, 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:`,
+      `"${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, and page_count the script so far${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}`),
+      // On a thin wall a match is arithmetic, and the row says so where it says "here" (round twenty, entry 54).
+      ...describeComparison(comparison).map((line) => `  - ${short ? line.replace(/\bhere\b/, "here, by arithmetic") : line}`),
       comparison.unmatched.length
         ? `beats of the wall no beat of the structure answers: ${comparison.unmatched.map((beat) => `"${beat.headline}" (p. ${beat.page})`).join(", ")}`
         : "every beat of the wall answers one of the structure's",
@@ -2726,7 +2750,7 @@ server.registerTool(
   {
     title: "Set when scenes happen",
     description:
-      "When one or more scenes happen, as the writer would say it — \"night\", \"day four, dawn\", \"the next morning\" — on the card beside its place, and printed after the place on every scene heading: THE PIER AT FENIT - NIGHT. Free text, the writer's phrase; an empty string clears it. Or leave the when open: pass open with the writer's words for why it is not decided — \"after the break-in; which day\" — and the reading lists it under open, by the writer's word, while the card's other questions still stand; a when decides it, open \"\" leaves it blank. This is where a scene's day and time live, not the headline, so the duplicate check never reads a day as a scene's words. create_note and update_note take when too; list_board shows it as when: …",
+      "When one or more scenes happen, as the writer would say it — \"night\", \"day four, dawn\", \"the next morning\" — on the card beside its place, and printed after the place on every scene heading: THE PIER AT FENIT - NIGHT. Free text, the writer's phrase; an empty string clears it. Or leave the when open: pass open with the writer's words for why it is not decided — \"after the party; which night\" — and the reading lists it under open, by the writer's word, while the card's other questions still stand; a when decides it, open \"\" leaves it blank. This is where a scene's day and time live, not the headline, so the duplicate check never reads a day as a scene's words. create_note and update_note take when too; list_board shows it as when: …",
     inputSchema: { ids: z.array(z.string()).min(1), when: z.string().optional(), open: z.string().optional() },
   },
   async (args) => {
@@ -2990,12 +3014,15 @@ 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.whenOpen ? `when open: "${note.whenOpen}"` : "", note.rank === "beat" ? "beat" : "", note.open ? `open: "${note.open}"` : ""].filter(Boolean).join(" · ");
+    const where_ = (note) => [note.location ? `at ${note.location}` : note.locationOpen ? `where open: "${note.locationOpen}"` : "", note.when ? note.when : note.whenOpen ? `when open: "${note.whenOpen}"` : "", 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)})`,
       `${person.name} (${person.id}) — on ${total} card${total === 1 ? "" : "s"} across ${project.boards.length} board${project.boards.length === 1 ? "" : "s"} of the project`,
-      ...CHARACTER_FIELDS.map((field) => `  ${field}: ${(person[field] ?? "").trim() || "(empty)"}`),
+      // Four empty lines say the same thing four times (round twenty, entry 56): once is enough, and it says what empty means.
+      ...(CHARACTER_FIELDS.every((field) => !(person[field] ?? "").trim())
+        ? [`  ${CHARACTER_FIELDS.join(", ")}: (empty — nothing given yet, nothing invented; update_character fills a line)`]
+        : CHARACTER_FIELDS.map((field) => `  ${field}: ${(person[field] ?? "").trim() || "(empty)"}`)),
       ...parts.flatMap((part) =>
         part.on.length
           ? [`  "${part.meta.name}", ${part.on.length} card${part.on.length === 1 ? "" : "s"} in story order:`, ...part.on.map((note, index) => `    ${index + 1}. "${note.headline}"${where_(note) ? ` (${where_(note)})` : ""}`)]
@@ -3064,14 +3091,16 @@ server.registerTool(
   {
     title: "Set where scenes happen",
     description:
-      "Set the place of one or more cards: where the scene happens, as the writer would say it ('the piano shop', 'the flat, kitchen') — a phrase, not a slugline. The same phrase on several cards is one place in the Cast panel; an empty string clears it. list_board shows each card's place as 'at: …'.",
-    inputSchema: { ids: z.array(z.string()).min(1), location: z.string() },
+      "Set the place of one or more cards: where the scene happens, as the writer would say it ('the piano shop', 'the flat, kitchen') — a phrase, not a slugline. The same phrase on several cards is one place in the Cast panel; an empty string clears it. Or leave the place open: pass open with the writer's words for why it is not decided — \"where it happens\" — and the reading lists it under open, by the writer's word, and stops asking where, while the card's other questions stand; a place decides it, open \"\" leaves it blank. list_board shows each card's place as 'at: …'.",
+    inputSchema: { ids: z.array(z.string()).min(1), location: z.string().optional(), open: z.string().optional() },
   },
   async (args) => {
+    if (args.location === undefined && args.open === undefined) return ok("Say which: location (the place, or \"\" to clear it), or open (the writer's words for why it is not decided).");
     const { state, changed, result, live } = await commit({
       type: "set_location",
       ids: args.ids,
-      location: args.location,
+      ...(args.location !== undefined ? { location: args.location } : {}),
+      ...(args.open !== undefined ? { open: args.open } : {}),
     });
     if (!changed) {
       const known = args.ids.filter((id) => state.notes.some((note) => note.id === id));
@@ -3079,6 +3108,10 @@ server.registerTool(
       return ok("No place changed: those cards already read that way.");
     }
     const place = result[0].location;
+    const placeOpen = result[0].locationOpen ?? "";
+    if (placeOpen) {
+      return ok(`${result.length} card(s) have their place left open, by the writer's word: "${placeOpen}"${where(live)}. The reading lists it and stops asking where; the heading prints the headline in its stead; set_location with a place decides it, open "" leaves it blank. The card is still asked about everything else.${stillOpen(result)}`, result);
+    }
     return ok(
       `${result.length} card(s) now ${place ? `at ${place}` : "nowhere"}${where(live)}.${nearPlaces(state, place)}${stillOpen(result)}`,
       result,
@@ -3191,7 +3224,8 @@ function foldLine(state, fold, thread) {
   const head = (id) => `"${state.notes.find((note) => note.id === id)?.headline ?? id}"`;
   if (fold.kept) return ` ${head(fold.firstId)} is folded for ${fold.what}, so "${thread.name}" stays a thread and no arrow is drawn: a card has one fold.`;
   const did = [fold.folded ? `folded ${head(fold.firstId)}` : null, fold.named ? `named its fold "${thread.name}"` : null, fold.arrow ? `drew the setup arrow to ${head(fold.lastId)}` : null].filter(Boolean);
-  return did.length ? ` Tied at both ends, so it is the fold's now: ${did.join(", ")}.` : "";
+  const adjacent = fold.adjacent ? ` No setup arrow: a follows arrow already runs from ${head(fold.firstId)} to ${head(fold.lastId)}, so the payoff is the very next scene and the fold says so on its own.` : "";
+  return did.length ? ` Tied at both ends, so it is the fold's now: ${did.join(", ")}.${adjacent}` : adjacent;
 }
 
 function threadLine(state, thread) {
@@ -3483,7 +3517,7 @@ server.registerTool(
     const { project, boards, live, base, changedAt } = await readProject();
     return ok(
       [
-        `Project "${project.name}" (${door(live, base)})`,
+        `Project "${project.name}"${project.nameOpen ? ` — its name is open, by the writer's word: "${project.nameOpen}"` : ""} (${door(live, base)})`,
         `premise: ${project.premiseOpen ? `open, by the writer's word — "${project.premiseOpen}"` : project.premise ? `"${project.premise}"` : "(not set)"}`,
         `boards: ${project.boards.length}`,
         describeBoards(project, boards, changedAt),
@@ -3508,7 +3542,7 @@ server.registerTool(
   {
     title: "Set the project's premise",
     description:
-      "Set the project's premise: the line above every board's logline, held by the project whatever its board count — what a series is about, or what is true before a film starts ('the winter the shop closes'). An empty string clears it. Or leave it open: pass open with the writer's words for why there is no premise yet — \"the buyer: housing, or a supermarket\" — and the reading lists it under open, by the writer's word; a premise decides it, open \"\" leaves it blank. Boards keep their own loglines.",
+      "Set the project's premise: the line above every board's logline, held by the project whatever its board count — what a series is about, or what is true before a film starts ('the winter the shop closes'). An empty string clears it. Or leave it open: pass open with the writer's words for why there is no premise yet — \"the buyer: a sale, or a lease\" — and the reading lists it under open, by the writer's word; a premise decides it, open \"\" leaves it blank. Boards keep their own loglines.",
     inputSchema: { premise: z.string().optional(), open: z.string().optional() },
   },
   async (args) => {
@@ -3526,11 +3560,18 @@ server.registerTool(
   "rename_project",
   {
     title: "Rename the project",
-    description: "Rename the project — the name at the top of the wall, over every board.",
-    inputSchema: { name: z.string().min(1) },
+    description: "Rename the project — the name at the top of the wall, over every board. Or leave its name open: pass open with the writer's words for why the title is not decided — \"The Allotments, or Plot 14\" — and the name stands as it is while the reading lists the words; a name decides it, open \"\" takes the words back.",
+    inputSchema: { name: z.string().min(1).optional(), open: z.string().optional() },
   },
   async (args) => {
+    if (args.name === undefined && args.open === undefined) return ok("Say which: name, or open (the writer's words for why the title is not decided).");
     const { project, boards, rev, base, live } = await readProject();
+    if (args.name === undefined) {
+      const opened = setProjectNameOpen(project, args.open);
+      if (opened === project) return ok("Project name unchanged: it already reads that way.");
+      await writeProject(opened, boards, rev, base);
+      return ok(opened.nameOpen ? `The project keeps its name, "${opened.name}", and its name is left open, by the writer's word: "${opened.nameOpen}"${where(live)}. The reading lists it; rename_project with a name decides it.` : `The project's name, "${opened.name}", is no longer open${where(live)}.`, { name: opened.name, nameOpen: opened.nameOpen });
+    }
     const next = renameProject(project, args.name);
     if (next === project) return ok("Project name unchanged.");
     await writeProject(next, boards, rev, base);
@@ -3538,7 +3579,7 @@ server.registerTool(
     // follow the rename (round fifteen, entry 40).
     if (accountDoor) workingProject(next.id, next.name);
     const several = (next.boards ?? []).length > 1;
-    return ok(`Project renamed to "${next.name}"${where(live)}. It shows at the head of every reply, in list_boards and read_wall, and as the title of every script out${several ? `, where each board follows it as an episode line (Episode 1 of ${next.boards.length} · ${next.boards[0].name})` : ""}. The boards keep their names.`, next);
+    return ok(`Project renamed to "${next.name}"${where(live)}.${project.nameOpen ? " Its name is decided; the open words are gone." : ""} It shows at the head of every reply, in list_boards and read_wall, and as the title of every script out${several ? `, where each board follows it as an episode line (Episode 1 of ${next.boards.length} · ${next.boards[0].name})` : ""}. The boards keep their names.`, next);
   },
 );
 
@@ -3716,13 +3757,17 @@ 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. board names the first board; boardOpen leaves its name open in the writer's words instead (\"the title, or Feature\"), so a board born from a maybe is not silently \"Board 1\".",
-    inputSchema: { name: z.string().min(1), board: z.string().optional(), boardOpen: z.string().optional(), pages: pagesSchema.optional(), minutes: z.number().positive().optional() },
+      "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() },
   },
   async (args) => {
     const account = await findAccount();
     if (!account) return shut("No account door: there is one project here, the open one. Set PLOTCODER_EMAIL and PLOTCODER_PASSWORD to start another on the writer's account.");
-    let record = renameProject(emptyProject(), args.name.trim());
+    if (!args.name?.trim() && !args.open?.trim()) return ok("Say which: name (the title), or open (the writer's words for why the title is not decided — the project starts as \"Untitled project\" with those words beside it).");
+    let record = emptyProject();
+    if (args.name?.trim()) record = renameProject(record, args.name.trim());
+    // A project born from a maybe is born open on its name (R61's edge): open holds the writer's words.
+    if (args.open?.trim()) record = setProjectNameOpen(record, args.open);
     if (args.board?.trim()) record = renameBoard(record, record.activeBoardId, args.board.trim());
     // A board born from a maybe is born open on its name (R61): boardOpen holds the writer's words.
     if (args.boardOpen?.trim()) record = setBoardNameOpen(record, record.activeBoardId, args.boardOpen);
@@ -3736,7 +3781,7 @@ server.registerTool(
     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 first = record.boards[0];
-    const nameOpenLine = first.nameOpen ? ` The board's name is left open, by the writer's word: "${first.nameOpen}"; rename_board decides it.` : "";
+    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 });
   },
 );
@@ -3837,7 +3882,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, 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.`,
+      `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()} — this session's own folder when the server was started from it, and somewhere else when it was not; 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) => {
@@ -3957,7 +4002,7 @@ server.registerTool(
   "rename_board",
   {
     title: "Rename board",
-    description: "Rename a board of the project by id, name, or number. Or leave its name open: pass open with the writer's words for why it is not decided — \"the title, or Feature\" — and the name stands as it is (every reply still calls it that) while the reading lists the words; a name decides it, open \"\" takes the words back.",
+    description: "Rename a board of the project by id, name, or number. Or leave its name open: pass open with the writer's words for why it is not decided — \"the pilot, or the film\" — and the name stands as it is (every reply still calls it that) while the reading lists the words; a name decides it, open \"\" takes the words back.",
     inputSchema: { board: z.union([z.string().min(1), z.number()]), name: z.string().min(1).optional(), open: 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. A thing the writer has not decided is an open card in their words (set_open), or an open field — the logline, the premise, a when, a board's name take open beside the value — 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.",
+    "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), or an open field — the logline, the premise, a card's place or when, a board's or the project's name take open beside the value — 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.",

package/src/board/fountain.js

@@ -124,6 +124,7 @@ export function toFountain(state, options = {}) {
     if (cast.length) marks.push(`with ${cast.join(", ")}`);
     if (note.plants) marks.push(note.plantsWhat ? `plants ${note.plantsWhat}` : "plants something to pay off later");
     if (note.open) marks.push(`open: ${note.open}`);
+    if (note.locationOpen) marks.push(`place open: ${note.locationOpen}`);
     if (note.whenOpen) marks.push(`when open: ${note.whenOpen}`);
     const onThreads = (state.threads ?? []).filter((thread) => thread.noteIds.includes(note.id)).map((thread) => thread.name);
     if (onThreads.length) marks.push(`thread: ${onThreads.join(", ")}`);

package/src/board/project.d.ts

@@ -19,6 +19,8 @@ export type ProjectRecord = {
   version: number;
   id: string;
   name: string;
+  /** The writer's words for why the project's name is not decided (R61's edge), or empty; the name stands meanwhile. */
+  nameOpen: string;
   premise: string;
   /** The writer's words for why there is no premise yet (R61), or empty. */
   premiseOpen: string;
@@ -75,6 +77,8 @@ export declare function setPremise(project: ProjectRecord, premise: string, now?
 export declare function setPremiseOpen(project: ProjectRecord, words: string, now?: string): ProjectRecord;
 /** The writer's words for why a board's name is not decided (R61); the name stands meanwhile. */
 export declare function setBoardNameOpen(project: ProjectRecord, id: string, words: string, now?: string): ProjectRecord;
+/** The writer's words for why the project's name is not decided (R61's edge); the name stands meanwhile. */
+export declare function setProjectNameOpen(project: ProjectRecord, words: string, now?: string): ProjectRecord;
 export declare function boardById(project: ProjectRecord, id: string): BoardMeta | null;
 /** What a script going out is called: a named project is the title, its board beside it only when the project has several. */
 export declare function scriptTitles(project: ProjectRecord, board: BoardMeta | null | undefined): { title: string; episode?: string };

package/src/board/project.js

@@ -33,6 +33,7 @@ export function emptyProject(now = nowIso()) {
     version: PROJECT_VERSION,
     id: newId(),
     name: DEFAULT_PROJECT_NAME,
+    nameOpen: "",
     premise: "",
     premiseOpen: "",
     boards: [board],
@@ -87,6 +88,8 @@ export function normalizeProject(value, now = nowIso()) {
     ...rest,
     version: PROJECT_VERSION,
     name: trimmed(value.name, DEFAULT_PROJECT_NAME),
+    // A project named before R61's edge has no open name; the name stands until the writer says it is not decided.
+    nameOpen: openWords(value.nameOpen),
     premise: typeof value.premise === "string" ? value.premise.trim() : "",
     // A project written before R61 has no open premise (R61).
     premiseOpen: openWords(value.premiseOpen),
@@ -342,8 +345,16 @@ export function setActiveBoard(project, id, now = nowIso()) {
 
 export function renameProject(project, name, now = nowIso()) {
   const next = trimmed(name, "");
-  if (!next || next === project.name) return project;
-  return touch(project, { name: next }, now);
+  if (!next || (next === project.name && !(project.nameOpen ?? ""))) return project;
+  // A name decides the field: the open words go (R61's edge).
+  return touch(project, { name: next, nameOpen: "" }, now);
+}
+
+/** The writer's words for why the project's name is not decided (R61's edge), or "" to take them back; the name stands meanwhile. */
+export function setProjectNameOpen(project, words, now = nowIso()) {
+  const next = openWords(words);
+  if (next === (project.nameOpen ?? "")) return project;
+  return touch(project, { nameOpen: next }, now);
 }
 
 export function setPremise(project, premise, now = nowIso()) {

package/src/board/readWall.d.ts

@@ -72,9 +72,9 @@ export type WallReading = {
   /** 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[] }>;
   /** 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: "when"; id: string; words: string }>;
+  openFields: Array<{ field: "logline"; words: string } | { field: "location"; id: string; words: string } | { field: "when"; id: string; words: 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 }>;
+  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. */
   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

@@ -17,7 +17,11 @@
 // before any tidy — the arrows are the writer's claim about the order, and
 // where they say nothing the positions decide.
 
-import { isMeasured, boardEighths, EIGHTHS_PER_PAGE, formatPages, NOTE_HEIGHT, noteEighths } from "./reducer.js";
+import { isMeasured, boardEighths, EIGHTHS_PER_PAGE, formatPages, noteEighths, readingOrder, storyOrder } from "./reducer.js";
+
+// The two orders live in the kernel (R62: a thread's cards are held in story
+// order), and every reader still imports them from here.
+export { readingOrder, storyOrder };
 
 /** What create_note writes before a person has. */
 export const PLACEHOLDER_HEADLINE = "New beat";
@@ -29,7 +33,6 @@ const SAG_RATIO = 2;
 // Longer than this and a group is probably two sequences wearing one frame.
 const SEQUENCE_MAX_EIGHTHS = 20 * EIGHTHS_PER_PAGE;
 // Two cards whose tops are within half a card of each other share a row.
-const ROW_TOLERANCE = NOTE_HEIGHT / 2;
 // A character gone for more than this share of the story is worth asking about.
 const ABSENCE_FRACTION = 1 / 3;
 // ...and at least this long, so a short wall of one-page estimates does not
@@ -45,64 +48,12 @@ const FILLER = new Set([
   "about", "into", "from", "by", "his", "her", "hers", "its", "their", "is", "it",
 ]);
 
-/**
- * Cards in reading order: banded into rows by y, then left to right. A free
- * wall has no rows, so this is the order a person's eye takes across it.
- */
-/**
- * Story order: reading order, with each follows arrow pulling its source in
- * front of its target; a pair pointing both ways is a tie and reading order
- * keeps it. The order organize lays the wall out in, and the order every
- * reading, numbering and page uses (R56). Returns the 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 reading = readingOrder(notes);
-  const byId = new Map(reading.map((note) => [note.id, note]));
-  const rank = new Map(reading.map((note, index) => [note.id, index]));
-  const preds = new Map(reading.map((note) => [note.id, []]));
-  for (const arrow of state.arrows ?? []) {
-    if (arrow.kind === "setup") continue;
-    if (!rank.has(arrow.from) || !rank.has(arrow.to)) continue;
-    preds.get(arrow.to).push(arrow.from);
-  }
-  for (const list of preds.values()) list.sort((a, b) => rank.get(a) - rank.get(b));
-  const placed = new Set();
-  const visiting = new Set();
-  const order = [];
-  function visit(id) {
-    if (placed.has(id) || visiting.has(id)) return;
-    visiting.add(id);
-    for (const from of preds.get(id)) {
-      if (preds.get(from).includes(id)) continue;
-      visit(from);
-    }
-    visiting.delete(id);
-    placed.add(id);
-    order.push(byId.get(id));
-  }
-  for (const note of reading) visit(note.id);
-  return order;
-}
+
 
 /** The leading "Day three, night." of a headline, the convention the guide asks for until a card has a when: not a scene's words. */
 const DAY_PREFIX = /^\s*day\s+[\w-]+(?:\s*,\s*[\w\s-]+?)?\s*[.:]\s*/i;
 
-export function readingOrder(notes) {
-  const byTop = [...notes].sort((a, b) => a.y - b.y || a.x - b.x);
-  const rows = [];
-  let row = null;
-  for (const note of byTop) {
-    if (row && note.y - row.top <= ROW_TOLERANCE) {
-      row.notes.push(note);
-    } else {
-      row = { top: note.y, notes: [note] };
-      rows.push(row);
-    }
-  }
-  return rows.flatMap((band) => band.notes.sort((a, b) => a.x - b.x || a.y - b.y));
-}
+
 
 function words(text) {
   return (text ?? "")
@@ -112,9 +63,9 @@ function words(text) {
     .filter((word) => word && !FILLER.has(word));
 }
 
-function sameScene(a, b) {
-  const wa = words(a);
-  const wb = words(b);
+function sameScene(a, b, ignore = new Set()) {
+  const wa = words(a).filter((word) => !ignore.has(word));
+  const wb = words(b).filter((word) => !ignore.has(word));
   if (wa.length === 0 || wb.length === 0) return false;
   if (wa.join(" ") === wb.join(" ")) return true;
   if (wa.length < 2 || wb.length < 2) return false;
@@ -265,7 +216,7 @@ export function readWall(state, options = {}) {
   // On a wall where most runs hold nothing, the turns are back to back by
   // construction, and the question stands until scenes go in; say so rather
   // than ask it as if it were a choice (round eighteen, entry 29).
-  const thin = between.length >= 2 && between.filter((run) => run.cards === 0).length * 2 > between.length ? " Most runs hold nothing yet, so this stands until scenes go in." : "";
+  const thin = between.length >= 2 && between.filter((run) => run.cards === 0).length * 2 > between.length ? " Most runs hold nothing yet, so this stands until scenes go in, or until the writer leaves it as the pace." : "";
   const askChain = () => {
     if (chain.length === 0) return;
     const ids = [chain[0].from, ...chain.map((run) => run.to)];
@@ -275,8 +226,8 @@ export function readWall(state, options = {}) {
       ids,
       text:
         ids.length === 2
-          ? `Nothing runs between ${names[0]} and ${names[1]}: two turns back to back. Are they one beat, or is a scene missing?${thin}`
-          : `Nothing runs between ${names.slice(0, -1).join(", ")} and ${names[names.length - 1]}: ${countWord(ids.length)} turns back to back. Are some of them one beat, or are scenes missing between them?${thin}`,
+          ? `Nothing runs between ${names[0]} and ${names[1]}: two turns back to back. Are they one beat, is a scene missing, or is that the pace?${thin}`
+          : `Nothing runs between ${names.slice(0, -1).join(", ")} and ${names[names.length - 1]}: ${countWord(ids.length)} turns back to back. Are some of them one beat, are scenes missing between them, or is that the pace?${thin}`,
     });
     chain = [];
   };
@@ -290,7 +241,8 @@ export function readWall(state, options = {}) {
   // A card that says no place, once the writer has started placing cards.
   // One question however many there are; a wall with no places at all is a
   // wall the writer has not placed yet, and is not asked.
-  const unplaced = order.filter((note) => askable(note) && !(note.location ?? "").trim());
+  // A place left open in the writer's words (R61's edge) is listed, not asked.
+  const unplaced = order.filter((note) => askable(note) && !(note.location ?? "").trim() && !(note.locationOpen ?? "").trim());
   if (unplaced.length > 0 && unplaced.length < order.length) {
     findings.push({
       kind: "unplaced",
@@ -323,8 +275,12 @@ export function readWall(state, options = {}) {
   }
 
   // Only once the wall uses arrows does a card without one mean anything.
+  // A setup arrow is a claim, not a place in the story (round twenty, entry
+  // 25): a card touched only by one still has no order, so only follows
+  // arrows link a card.
   const linked = new Set();
   for (const arrow of state.arrows) {
+    if (arrow.kind === "setup") continue;
     linked.add(arrow.from);
     linked.add(arrow.to);
   }
@@ -339,14 +295,17 @@ export function readWall(state, options = {}) {
     }
   }
 
-  // Two cards doing the same job.
+  // Two cards doing the same job. The cast's names are not the scene's words
+  // (round twenty, entry 15): "Con gives Ruth the key" and "Con gives Ruth
+  // his tools" share their people, not their job.
+  const nameWords = new Set((state.characters ?? []).flatMap((person) => words(person.name ?? "")));
   for (let i = 0; i < order.length; i += 1) {
     for (let j = i + 1; j < order.length; j += 1) {
       const a = order[i];
       const b = order[j];
       // A leading "Day three." is the guide's convention for when a scene
       // happens, not the scene's words (round fourteen, entry 13).
-      if (sameScene(a.headline.replace(DAY_PREFIX, ""), b.headline.replace(DAY_PREFIX, ""))) {
+      if (sameScene(a.headline.replace(DAY_PREFIX, ""), b.headline.replace(DAY_PREFIX, ""), nameWords)) {
         findings.push({
           kind: "duplicate",
           ids: [a.id, b.id],
@@ -505,13 +464,12 @@ 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,
-  }));
+  const threads = (state.threads ?? []).map((thread) => {
+    const ids = order.filter((note) => thread.noteIds.includes(note.id)).map((note) => note.id);
+    // How far the string runs, in the same estimated pages a setup's distance uses (round twenty, entry 44).
+    const apart = ids.length >= 2 ? (startAt.get(ids[ids.length - 1]) ?? 0) - (startAt.get(ids[0]) ?? 0) : 0;
+    return { id: thread.id, name: thread.name, ids, startOpen: thread.startOpen === true, endOpen: thread.endOpen === true, apart };
+  });
   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;
@@ -578,6 +536,7 @@ export function readWall(state, options = {}) {
 function describeOpenFields(state, order) {
   const fields = [];
   if ((state.loglineOpen ?? "").trim()) fields.push({ field: "logline", words: state.loglineOpen.trim() });
+  for (const note of order) if ((note.locationOpen ?? "").trim()) fields.push({ field: "location", id: note.id, words: note.locationOpen.trim() });
   for (const note of order) if ((note.whenOpen ?? "").trim()) fields.push({ field: "when", id: note.id, words: note.whenOpen.trim() });
   return fields;
 }
@@ -635,6 +594,7 @@ export function describeRuns(reading, state) {
     // from written text, or the cards' guess, or some of each.
     const written = (run.ids ?? []).filter((id) => isMeasured(byId.get(id) ?? {})).length;
     const whose = !run.cards ? "" : written === run.cards ? ", measured" : written ? `, ${written} of ${run.cards} measured` : ", estimated";
-    return `${span}: about ${pages(run.eighths)} pages, ${count}${whose}`;
+    const amount = pages(run.eighths);
+    return `${span}: about ${amount} ${amount === "1" ? "page" : "pages"}, ${count}${whose}`;
   });
 }

package/src/board/reducer.d.ts

@@ -93,6 +93,8 @@ export type BoardNote = {
   when: string;
   /** The writer's words for why the when is not decided (R61), or empty; while they stand the when is blank and the reading lists them. */
   whenOpen: string;
+  /** The writer's words for why the place is not decided (R61's edge), or empty; while they stand the place is blank, listed, and not asked. */
+  locationOpen: string;
   /** The scene's text in Fountain (R23 b): action, cues, dialogue; empty until written. */
   text: string;
   createdAt: string;
@@ -186,6 +188,7 @@ export type Command =
       location?: string;
       when?: string;
       whenOpen?: string;
+      locationOpen?: string;
       open?: string;
       text?: string;
     }
@@ -216,7 +219,7 @@ export type Command =
   | { type: "set_plant"; ids: string[]; plants?: boolean; what?: string }
   | { type: "set_open"; ids: string[]; open: string }
   | { type: "set_payoff_board"; ids: string[]; boardId: string | null; noteId?: string | null }
-  | { type: "set_location"; ids: string[]; location: string }
+  | { type: "set_location"; ids: string[]; location?: string; open?: string }
   | { type: "set_when"; ids: string[]; when?: string; open?: string }
   | { type: "apply_template"; template: string; beats?: Array<{ name: string; prompt: string; at: number }> }
   | { type: "set_text"; id: string; text: string }

package/src/board/reducer.js

@@ -247,6 +247,8 @@ export function seedState(now = nowIso()) {
     lengthEighths: null,
     characterIds,
     location: "",
+    // The writer's words for why the place is not decided (R61), or nothing.
+    locationOpen: "",
     when: "",
     // The writer's words for why the when is not decided (R61), or nothing.
     whenOpen: "",
@@ -368,6 +370,8 @@ export function normalizeState(value) {
     const open = typeof note?.open === "string" ? note.open : "";
     // 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.
+    const locationOpen = typeof note?.locationOpen === "string" ? note.locationOpen : "";
     // Cards written before R55 have no when; a scene is at no time until it is.
     const when = typeof note?.when === "string" ? note.when : "";
     // Cards written before R61 have no open when; a when is decided or blank until the writer says otherwise.
@@ -386,6 +390,7 @@ export function normalizeState(value) {
       note.payoffNoteId === payoffNoteId &&
       note.open === open &&
       note.location === location &&
+      note.locationOpen === locationOpen &&
       note.when === when &&
       note.whenOpen === whenOpen &&
       note.text === text
@@ -393,7 +398,7 @@ export function normalizeState(value) {
       return note;
     }
     patched = true;
-    return { ...note, rank, lengthEighths, characterIds, plants, plantsWhat, payoffBoardId, payoffNoteId, open, location, when, whenOpen, text };
+    return { ...note, rank, lengthEighths, characterIds, plants, plantsWhat, payoffBoardId, payoffNoteId, open, location, locationOpen, when, whenOpen, text };
   });
 
   // Boards written before the production half (Roadmap 2, item 8) have no
@@ -474,6 +479,73 @@ function cleanOpen(value) {
   return typeof value === "string" ? value.trim().replace(/\s+/g, " ") : "";
 }
 
+
+// --- Order (R56, moved here for R62) -------------------------------------
+//
+// Story order is the follows arrows where they exist and the wall's reading
+// order — rows top to bottom, cards left to right — where they do not. The
+// reading composes everything from it; the kernel needs it to hold a
+// thread's cards in story order, so the tie rule folds the first card and
+// not the last one the writer happened to add.
+
+/** Cards within half a card's height of each other sit on one row. */
+const ROW_TOLERANCE = NOTE_HEIGHT / 2;
+
+export function readingOrder(notes) {
+  const byTop = [...notes].sort((a, b) => a.y - b.y || a.x - b.x);
+  const rows = [];
+  let row = null;
+  for (const note of byTop) {
+    if (row && note.y - row.top <= ROW_TOLERANCE) {
+      row.notes.push(note);
+    } else {
+      row = { top: note.y, notes: [note] };
+      rows.push(row);
+    }
+  }
+  return rows.flatMap((band) => band.notes.sort((a, b) => a.x - b.x || a.y - b.y));
+}
+
+/**
+ * Cards in reading order: banded into rows by y, then left to right. A free
+ * wall has no rows, so this is the order a person's eye takes across it.
+ */
+/**
+ * Story order: reading order, with each follows arrow pulling its source in
+ * front of its target; a pair pointing both ways is a tie and reading order
+ * keeps it. The order organize lays the wall out in, and the order every
+ * reading, numbering and page uses (R56). Returns the 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 reading = readingOrder(notes);
+  const byId = new Map(reading.map((note) => [note.id, note]));
+  const rank = new Map(reading.map((note, index) => [note.id, index]));
+  const preds = new Map(reading.map((note) => [note.id, []]));
+  for (const arrow of state.arrows ?? []) {
+    if (arrow.kind === "setup") continue;
+    if (!rank.has(arrow.from) || !rank.has(arrow.to)) continue;
+    preds.get(arrow.to).push(arrow.from);
+  }
+  for (const list of preds.values()) list.sort((a, b) => rank.get(a) - rank.get(b));
+  const placed = new Set();
+  const visiting = new Set();
+  const order = [];
+  function visit(id) {
+    if (placed.has(id) || visiting.has(id)) return;
+    visiting.add(id);
+    for (const from of preds.get(id)) {
+      if (preds.get(from).includes(id)) continue;
+      visit(from);
+    }
+    visiting.delete(id);
+    placed.add(id);
+    order.push(byId.get(id));
+  }
+  for (const note of reading) visit(note.id);
+  return order;
+}
 /**
  * The combine log's rule, both halves (R60, R62). A thread tied at both ends
  * through two or more cards is a plant between two scenes that exist, and
@@ -504,16 +576,20 @@ function tieIntoFold(state, thread, now) {
       notes: next.notes.map((note) => (note.id === firstId ? bump(note, { plants: true, plantsWhat: thread.name }, now) : note)),
     };
   }
-  const hasArrow = next.arrows.some((arrow) => arrow.kind === "setup" && arrow.from === firstId && arrow.to === lastId);
+  // One arrow per direction between two cards (R15): a follows arrow already
+  // running from the first card to the last means the payoff is the very next
+  // scene, and the setup cannot be drawn over it.
+  const existing = next.arrows.find((arrow) => arrow.from === firstId && arrow.to === lastId);
   let arrow = null;
-  if (!hasArrow) {
+  const adjacent = Boolean(existing && existing.kind !== "setup");
+  if (!existing) {
     const drawn = applyCommand(next, { type: "create_arrow", from: firstId, to: lastId, kind: "setup" }, now);
     if (drawn.changed) {
       next = drawn.state;
       arrow = { from: firstId, to: lastId };
     }
   }
-  return { state: next, fold: { kept: false, firstId, lastId, folded, named, arrow } };
+  return { state: next, fold: { kept: false, firstId, lastId, folded, named, arrow, adjacent } };
 }
 
 /** A thread's name as the writer typed it, one line, spaces collapsed (R60). */
@@ -565,7 +641,8 @@ export function applyCommand(state, command, now = nowIso()) {
         payoffBoardId: null,
         payoffNoteId: null,
         open: cleanOpen(command.open),
-        location: cleanPlace(command.location),
+        location: cleanOpen(command.locationOpen) ? "" : cleanPlace(command.location),
+        locationOpen: cleanOpen(command.locationOpen),
         when: cleanOpen(command.whenOpen) ? "" : cleanWhen(command.when),
         whenOpen: cleanOpen(command.whenOpen),
         text: typeof command.text === "string" ? command.text : "",
@@ -809,7 +886,9 @@ export function applyCommand(state, command, now = nowIso()) {
     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 wanted = (command.noteIds ?? []).filter((id, index, all) => all.indexOf(id) === index && state.notes.some((note) => note.id === id));
+      // Held in story order, whatever order the writer named them (R62).
+      const noteIds = storyOrder(state, wanted).map((note) => note.id);
       const thread = {
         id: typeof command.id === "string" && command.id && !(state.threads ?? []).some((item) => item.id === command.id) ? command.id : newId(),
         name,
@@ -828,6 +907,9 @@ export function applyCommand(state, command, now = nowIso()) {
       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));
+      // Held in story order, whatever order the cards were added (R62): the
+      // rule below folds the first card in the story, not the last one named.
+      noteIds = storyOrder(state, noteIds).map((note) => note.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;
@@ -1089,6 +1171,7 @@ export function applyCommand(state, command, now = nowIso()) {
         payoffNoteId: null,
         open: "",
         location: "",
+        locationOpen: "",
         when: "",
         whenOpen: "",
         text: "",
@@ -1180,11 +1263,21 @@ export function applyCommand(state, command, now = nowIso()) {
     case "set_location": {
       const ids = new Set(command.ids);
       if (ids.size === 0) return { state, changed: false };
-      const location = cleanPlace(command.location);
+      // The place, or the writer's words for why there is none yet (R61's
+      // edge, round twenty entry 16): words clear the place, a place clears
+      // the words, open "" with a place does both in one command.
+      const hasOpen = typeof command.open === "string";
+      const locationOpen = hasOpen ? cleanOpen(command.open) : null;
+      const location = hasOpen ? (locationOpen ? "" : typeof command.location === "string" ? cleanPlace(command.location) : null) : cleanPlace(command.location);
       const touched = [];
       const notes = state.notes.map((note) => {
-        if (!ids.has(note.id) || note.location === location) return note;
-        const next = bump(note, { location }, now);
+        if (!ids.has(note.id)) return note;
+        const patch = {
+          location: location === null ? (note.location ?? "") : location,
+          locationOpen: locationOpen === null ? (location ? "" : (note.locationOpen ?? "")) : locationOpen,
+        };
+        if (patch.location === (note.location ?? "") && patch.locationOpen === (note.locationOpen ?? "")) return note;
+        const next = bump(note, patch, now);
         touched.push(next);
         return next;
       });

package/src/board/words.js

@@ -66,7 +66,7 @@ export const WORD_GROUPS = [
       {
         id: "open",
         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. A field can be open the same way — the logline, the premise, a card's when, a board's name — the words where the value would be, listed and not asked.",
+        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. A field can be open the same way — the logline, the premise, a card's place or when, a board's or the project's name — the words where the value would be, listed and not asked.",
       },
       {
         id: "thread",
@@ -77,7 +77,7 @@ export const WORD_GROUPS = [
         id: "corner",
         name: "The folded corner",
         sentence:
-          "This card plants something — a gun on the wall — that must pay off later, and can say what, in the writer’s words: Plants · the wrong tools. The card says unpaid, and the bar’s Asks line keeps asking where it comes back, until a setup arrow leaves it. One thing, three words: the corner is folded, the tool’s flag is plants, the wall’s question is unpaid.",
+          "This card plants something — a gun on the wall — that must pay off later, and can say what, in the writer’s words: Plants · the letter. The card says unpaid, and the bar’s Asks line keeps asking where it comes back, until a setup arrow leaves it. One thing, three words: the corner is folded, the tool’s flag is plants, the wall’s question is unpaid.",
         target: "corner",
       },
       {

package/src/board/workflows.js

@@ -25,6 +25,7 @@ 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? Not decided: either takes open with the writer's words, and the reading lists it.", tool: "set_logline, set_premise" },
+      { question: "In what order do the scenes come?", hint: "The follows arrows are the order, and the wall reads, numbers and prints by them: create_note with after wires each card as it lands, create_arrow draws one, move_scene moves a scene. Not decided for a card: leave it unwired and say so; the reading asks what comes before and after it.", tool: "create_note, create_arrow, move_scene" },
       { 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" },