plotcoder-board 0.1.30 → 0.1.32

package/README.md

@@ -104,4 +104,4 @@ next round into a test of `claim_account` instead of the door it meant to test.
 
 ## Status
 
-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.
+Version 0.1.32. 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.30",
+  "version": "0.1.32",
   "type": "module",
   "scripts": {
     "dev": "vite",

package/scripts/plotcoder-mcp-server.mjs

@@ -69,6 +69,8 @@ import {
   removeStructure,
   setActiveBoard,
   setPremise,
+  setPremiseOpen,
+  setBoardNameOpen,
   structureBeats,
   reidentifyProject,
   renameProject,
@@ -1057,13 +1059,14 @@ function summarize(state) {
       // The board it pays off on, named here as read_wall names it (round fifteen, entry 44).
       const laterName = note.payoffBoardId ? (lastHeld?.project?.boards?.find((meta) => meta.id === note.payoffBoardId)?.name ?? note.payoffBoardId) : null;
       const laterAt = note.payoffBoardId && note.payoffNoteId && lastHeld?.project ? ` at ${episodeLabel(lastHeld.project, lastHeld.boards, note.payoffBoardId, note.payoffNoteId)} "${lastHeld.boards[note.payoffBoardId]?.notes?.find((item) => item.id === note.payoffNoteId)?.headline ?? note.payoffNoteId}"` : "";
-      const plant = note.plants ? (note.payoffBoardId ? `, plants → pays off later on "${laterName}"${laterAt || ", no scene there claimed yet"}` : ", plants") : "";
+      const what = note.plantsWhat ? `: ${note.plantsWhat}` : "";
+      const plant = note.plants ? (note.payoffBoardId ? `, plants${what} → pays off later on "${laterName}"${laterAt || ", no scene there claimed yet"}` : `, plants${what}`) : "";
       // The receiving end (R58): what this card pays off from another board, composed from the project.
       const pays = paidByHere.filter((item) => item.id === note.id).map((item) => `, pays off "${item.fromHeadline}" from "${item.fromBoardName}" (${episodeLabel(lastHeld.project, lastHeld.boards, item.fromBoardId, item.fromNoteId)})`).join("");
       const snap = state.revision?.snapshot?.[note.id];
       const revised = snap && (snap.headline !== note.headline || snap.change !== note.change || (snap.text ?? "") !== (note.text ?? "") || (snap.location ?? "") !== (note.location ?? "")) ? `, changed in ${state.revision.color}` : "";
       const place = note.location ? `, at: ${note.location}` : "";
-      const when = note.when ? `, when: ${note.when}` : "";
+      const 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));
       // A written card's estimate is kept underneath for when the text goes; say it, or it is invisible (round sixteen, entry 44).
@@ -1134,7 +1137,7 @@ function summarize(state) {
   const leftCount = (state.left ?? []).length;
   return [
     ...(isSampleWall(state) ? [SAMPLE_NOTE] : []),
-    `logline: ${state.logline ? `"${state.logline}"` : "(not set)"}`,
+    `logline: ${state.loglineOpen ? `open, by the writer's word — "${state.loglineOpen}"` : state.logline ? `"${state.logline}"` : "(not set)"}`,
     ...production,
     `left, for now: ${leftCount ? `${leftCount} question(s) the writer left; read_wall lists them` : "none"}`,
     `beats: ${beats}, scenes: ${scenes}`,
@@ -1221,18 +1224,24 @@ server.registerTool(
   {
     title: "Set logline",
     description:
-      "Set the board's logline — the central question, what this story is arguing. One sentence. Every card on the wall should be checkable against it. Pass an empty string to clear it.",
+      "Set the board's logline — the central question, what this story is arguing. One sentence. Every card on the wall should be checkable against it. Pass an empty string to clear it. Or leave it open: pass open with the writer's words for why there is no logline yet — \"two candidates, not chosen\" — and the reading lists it under open, by the writer's word, and asks nothing; text decides it and clears the words; open \"\" takes the words back and leaves the field blank. Only on the writer's word: an open field is theirs, never a guess of yours.",
     inputSchema: {
-      logline: z.string(),
+      logline: z.string().optional(),
+      open: z.string().optional(),
     },
   },
   async (args) => {
-    const { state, live } = await commit({ type: "set_logline", logline: args.logline });
+    if (args.logline === undefined && args.open === undefined) return ok("Say which: logline (the sentence, or \"\" to clear it), or open (the writer's words for why there is none yet).");
+    const { state, changed, live } = await commit({ type: "set_logline", ...(args.logline !== undefined ? { logline: args.logline } : {}), ...(args.open !== undefined ? { open: args.open } : {}) });
+    if (!changed) return ok(args.logline === "" && !state.loglineOpen ? "Logline cleared." : "Logline unchanged: it already read that way.");
+    if (state.loglineOpen) {
+      return ok(`Logline left open, by the writer's word: "${state.loglineOpen}"${where(live)}. The reading lists it and asks nothing; set_logline with text decides it, open "" leaves it blank.`, { logline: state.logline, loglineOpen: state.loglineOpen });
+    }
     return ok(
       state.logline
         ? `Logline set: "${state.logline}"${where(live)}.`
-        : "Logline cleared.",
-      { logline: state.logline },
+        : `Logline cleared${where(live)}.`,
+      { logline: state.logline, loglineOpen: state.loglineOpen },
     );
   },
 );
@@ -1376,6 +1385,7 @@ server.registerTool(
         rank: args.rank,
         lengthEighths: args.pages === undefined ? undefined : toEighths(args.pages),
         plants: args.plants,
+        plantsWhat: args.plantsWhat,
         location: args.location,
         when: args.when,
         open: args.open,
@@ -1420,7 +1430,7 @@ server.registerTool(
       result?.rank === "beat" ? "a beat" : "a scene",
       result?.lengthEighths === null ? "about a page (unsized: the writer's guess until set_length)" : `${formatPages(noteEighths(result))} ${formatPages(noteEighths(result)) === "1" ? "page" : "pages"}`,
       result?.color ? `${result.color} paper${args.color ? "" : once("paper", " (pass color to choose)")}` : null,
-      result?.plants ? "corner folded" : null,
+      result?.plants ? `corner folded${result.plantsWhat ? ` — plants ${result.plantsWhat}` : ""}` : null,
       result?.location ? `at ${result.location}` : `no place yet${once("place", " (location here, or set_location)")}`,
       result?.when ? `when: ${result.when}` : null,
       result?.open ? `open: "${result.open}" (listed, not asked about)` : null,
@@ -1563,11 +1573,19 @@ server.registerTool(
     const whose = runtimeKinds(state).replace(/^; /, "");
     // A beat's own pages are in no run (entry 48); say how many pages that is.
     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 = [
+      ...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}`),
+    ];
     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 ?? "?"}"${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` : ""}`,
-      `logline: ${state.logline ? `"${state.logline}"` : "(none yet)"}`,
+      `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.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)`
@@ -1599,8 +1617,8 @@ server.registerTool(
         : [reading.paidBy.length ? "  (no setup arrow on this board; what pays off a fold of another board is listed below)" : "  (no arrow is marked as a setup)"]),
       ...reading.later.map((item) => `  - "${state.notes.find((note) => note.id === item.id)?.headline ?? item.id}" is folded and pays off later, on "${boardById(projectForRead, item.boardId)?.name ?? item.boardId}"${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 ? ` (closed, it would be asked ${item.hides.map((kind) => ASK_WORDS[kind] ?? CHECK_WORDS[kind] ?? kind).join("; ")})` : ""}`)]
+      ...(reading.open.length || openFieldLines.length
+        ? ["open, by the writer's word (listed, not asked about while the words stand; set_open with \"\" closes a card, the field's own tool with open \"\" a field):", ...openFieldLines, ...reading.open.map((item) => `  - "${state.notes.find((note) => note.id === item.id)?.headline ?? item.id}" — ${item.words}${item.hides.length ? ` (closed, it would be asked ${item.hides.map((kind) => ASK_WORDS[kind] ?? CHECK_WORDS[kind] ?? kind).join("; ")})` : ""}`)]
         : []),
       ...(reading.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" : ""}`)]
@@ -1622,7 +1640,7 @@ server.registerTool(
         const counts = new Map();
         for (const finding of asked) counts.set(finding.kind, (counts.get(finding.kind) ?? 0) + 1);
         return `asking ${asked.length} question${asked.length === 1 ? "" : "s"} of ${counts.size} kind${counts.size === 1 ? "" : "s"}: ${[...counts.entries()].map(([kind, n]) => (n > 1 ? `${kind} ×${n}` : kind)).join(", ")}${held}`;
-      })()}${reading.left.length ? `; left by the writer, so not clean: ${[...new Set(reading.left.map((finding) => finding.kind))].map((kind) => `[${kind}]`).join(" ")}` : ""}${reading.open.length ? `; ${reading.open.length} card${reading.open.length === 1 ? "" : "s"} open by the writer's word, not asked` : ""}; checked and clean: ${CHECKS.filter((kind) => !reading.findings.some((finding) => finding.kind === kind) && !reading.left.some((finding) => finding.kind === kind)).map((kind) => {
+      })()}${reading.left.length ? `; left by the writer, so not clean: ${[...new Set(reading.left.map((finding) => finding.kind))].map((kind) => `[${kind}]`).join(" ")}` : ""}${reading.open.length || openFieldLines.length ? `; ${[reading.open.length ? `${reading.open.length} card${reading.open.length === 1 ? "" : "s"}` : "", openFieldLines.length ? `${openFieldLines.length} field${openFieldLines.length === 1 ? "" : "s"}` : ""].filter(Boolean).join(" and ")} open by the writer's word, not asked` : ""}; checked and clean: ${CHECKS.filter((kind) => !reading.findings.some((finding) => finding.kind === kind) && !reading.left.some((finding) => finding.kind === kind)).map((kind) => {
         if (kind === "unlinked" && state.arrows.length === 0) return "no card without an arrow (not asked until half the cards are wired: no arrows yet)";
         if (kind === "unlinked") {
           const linked = new Set(state.arrows.flatMap((arrow) => [arrow.from, arrow.to]));
@@ -2708,16 +2726,21 @@ 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. 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() },
+      "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: …",
+    inputSchema: { ids: z.array(z.string()).min(1), when: z.string().optional(), open: z.string().optional() },
   },
   async (args) => {
-    const { state, changed, result, live } = await commit({ type: "set_when", ids: args.ids, when: args.when });
+    if (args.when === undefined && args.open === undefined) return ok("Say which: when (the writer's phrase, or \"\" to clear it), or open (their words for why the when is not decided).");
+    const { state, changed, result, live } = await commit({ type: "set_when", ids: args.ids, ...(args.when !== undefined ? { when: args.when } : {}), ...(args.open !== undefined ? { open: args.open } : {}) });
     if (!changed) {
       const missing = args.ids.filter((id) => !state.notes.some((note) => note.id === id));
-      return ok(missing.length ? `No card with id ${missing.join(", ")}. Call list_board for the real ids.` : `Nothing changed: ${args.ids.length === 1 ? "the card already says" : "those cards already say"} "${args.when.trim()}".`);
+      return ok(missing.length ? `No card with id ${missing.join(", ")}. Call list_board for the real ids.` : `Nothing changed: ${args.ids.length === 1 ? "the card already says" : "those cards already say"} "${(args.when ?? args.open ?? "").trim()}".`);
     }
     const when = result[0]?.when ?? "";
+    const whenOpen = result[0]?.whenOpen ?? "";
+    if (whenOpen) {
+      return ok(`${result.length} card(s) have their when left open, by the writer's word: "${whenOpen}"${where(live)}. The reading lists it and asks nothing; the heading prints no time; set_when with a when decides it, open "" leaves it blank. The card is still asked about everything else.${stillOpen(result)}`, result);
+    }
     return ok(
       when
         ? `${result.length} card(s) now happen ${/^(at|on|in|by|the)\b/i.test(when) ? "" : "at "}"${when}"${where(live)}. The heading prints as ${sceneHeading(result[0]).slice(1)}.${stillOpen(result)}`
@@ -2762,12 +2785,14 @@ server.registerTool(
       `Fold the corner of cards — mark them as planting something — or unfold them. ${wordSentence("corner")} The setup arrow is create_arrow with kind 'setup'. A fold that pays off in a later episode: pass later, another board of the project by name, id or number — a board that exists; new_board makes one — and, once you know it, at: the scene on that board that pays it off, by id or headline. A board alone is a promise: the reading lists the card under 'later' and, once that board holds cards, asks which scene until one claims it; with at, both boards' readings name the payoff and the paying-off card says so. later '' forgets the board; at '' keeps the board and forgets the scene. set_payoff makes the same claim from the other board. Folding never moves a card.`,
     inputSchema: {
       ids: z.array(z.string()).min(1),
-      plants: z.boolean(),
+      plants: z.boolean().optional(),
+      what: z.string().optional(),
       later: z.string().optional(),
       at: z.string().optional(),
     },
   },
   async (args) => {
+    if (args.plants === undefined && args.what === undefined) return ok("Say which: plants (true folds, false unfolds), or what (the writer's words for what it plants, which folds the card; \"\" keeps the fold and drops the words).");
     // A series plant (R50): the fold pays off on another board of the project.
     // The kernel cannot check the board exists; this door can, before anything lands.
     let target = null;
@@ -2802,7 +2827,7 @@ server.registerTool(
       // What the folds claimed before, so the reply can say what a new claim replaced (round sixteen, entry 26).
       const before = new Map(current().notes.filter((note) => args.ids.includes(note.id)).map((note) => [note.id, { plants: note.plants, boardId: note.payoffBoardId, noteId: note.payoffNoteId }]));
       const alreadyFolded = args.plants && args.ids.every((id) => before.get(id)?.plants);
-      let { result } = step({ type: "set_plant", ids: args.ids, plants: args.plants });
+      let { result } = step({ type: "set_plant", ids: args.ids, ...(args.plants !== undefined ? { plants: args.plants } : {}), ...(args.what !== undefined ? { what: args.what } : {}) });
       let laterLine = alreadyFolded ? " (already folded)" : "";
       if (forgetting) {
         const cleared = step({ type: "set_payoff_board", ids: args.ids, boardId: null });
@@ -2830,10 +2855,11 @@ server.registerTool(
     const { result, laterLine } = value;
     const count = result?.length ?? 0;
     if (!changed || count === 0) return ok("No change: those cards were already that way, or the ids are not on the board.");
+    const what = result?.[0]?.plantsWhat ?? "";
     return ok(
-      args.plants
-        ? `${count} card(s) now plant something${where(live)}.${laterLine || " read_wall will ask about each until a setup arrow pays it off, or later names the board it pays off on."}`
-        : `${count} card(s) no longer marked as planting${where(live)}.`,
+      args.plants !== false
+        ? `${count} card(s) now plant ${what ? `"${what}"` : "something"}${where(live)}.${what ? ` The card says "Plants · ${what}", and read_wall asks where ${what} come${/s$/i.test(what) ? "" : "s"} back` : " read_wall will ask about each"}${laterLine || " until a setup arrow pays it off, or later names the board it pays off on."}${args.what === "" ? " The fold keeps no words now." : ""}`
+        : `${count} card(s) no longer marked as planting${where(live)}.${result?.some((note) => !note.plantsWhat) && args.ids.length ? "" : ""}`,
       result,
     );
   },
@@ -2964,7 +2990,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.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)})`,
@@ -3159,6 +3185,15 @@ function cardsByRef(state, refs) {
   return { found, missing };
 }
 
+/** What tying a thread at both ends did to the fold (R62), in words for the reply. */
+function foldLine(state, fold, thread) {
+  if (!fold) return "";
+  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(", ")}.` : "";
+}
+
 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";
@@ -3187,7 +3222,7 @@ server.registerTool(
     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.`,
+      `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."}${foldLine(state, result.fold, result)} The wall draws it as a string through its cards, a loose end where one is open.`,
       result,
     );
   },
@@ -3229,7 +3264,7 @@ server.registerTool(
     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.` : ""}`,
+      `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.` : ""}${foldLine(state, result.fold, result.thread)}`,
       result.thread,
     );
   },
@@ -3430,7 +3465,8 @@ function describeBoards(project, boards, changedAt = null) {
           ? `${state.notes.length} cards, about ${formatPages(boardEighths(normalizeState(state)))} of ${formatPages(normalizeState(state).targetEighths)} pages`
           : "no cards";
       const changed = changedAt?.[board.id] ? `, last changed ${changedAt[board.id]}` : "";
-      return `  ${index + 1}. ${board.id} — "${board.name}"${open}: ${shape}${changed}`;
+      const nameOpen = board.nameOpen ? ` (name open, by the writer's word: "${board.nameOpen}")` : "";
+      return `  ${index + 1}. ${board.id} — "${board.name}"${nameOpen}${open}: ${shape}${changed}`;
     })
     .join("\n");
 }
@@ -3448,7 +3484,7 @@ server.registerTool(
     return ok(
       [
         `Project "${project.name}" (${door(live, base)})`,
-        `premise: ${project.premise ? `"${project.premise}"` : "(not set)"}`,
+        `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),
         // The project's length as one line, so a series is not arithmetic by hand (round fifteen, entry 38).
@@ -3472,14 +3508,16 @@ 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. Boards keep their own loglines.",
-    inputSchema: { premise: z.string() },
+      "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.",
+    inputSchema: { premise: z.string().optional(), open: z.string().optional() },
   },
   async (args) => {
+    if (args.premise === undefined && args.open === undefined) return ok("Say which: premise (the line, or \"\" to clear it), or open (the writer's words for why there is none yet).");
     const { project, boards, rev, base, live } = await readProject();
-    const next = setPremise(project, args.premise);
+    const next = args.open !== undefined ? setPremiseOpen(project, args.open) : setPremise(project, args.premise);
     if (next === project) return ok("Premise unchanged.");
     await writeProject(next, boards, rev, base);
+    if (next.premiseOpen) return ok(`Premise left open, by the writer's word: "${next.premiseOpen}"${where(live)}. The reading lists it and asks nothing; set_premise with a line decides it, open "" leaves it blank.`, next);
     return ok(`Premise ${next.premise ? `set to "${next.premise}"` : "cleared"}${where(live)}.`, next);
   },
 );
@@ -3678,14 +3716,16 @@ 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.",
-    inputSchema: { name: z.string().min(1), board: 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. 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() },
   },
   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.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);
     const inserted = await account.client.from("projects").insert({ id: record.id, record, reminders: null, rev: 1 });
     if (inserted.error) return ok(`Could not start the project: ${inserted.error.message}`);
     const target = args.pages ?? args.minutes;
@@ -3696,7 +3736,8 @@ 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];
-    return ok(`Started "${record.name}" (${record.id}) with its first board "${first.name}" (${first.id}), and working it now, as ${account.email}.${targetLine}${oneCallHint(record)}`, { id: record.id, name: record.name, boardId: first.id, boardName: first.name, targetEighths: state.targetEighths });
+    const nameOpenLine = 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 });
   },
 );
 
@@ -3894,19 +3935,19 @@ server.registerTool(
   {
     title: "New board",
     description:
-      "Add a board to the project and open it: an empty wall with the logline placeholder, under the same premise, with the same target length as the board that was open. Nothing else is touched — the other boards stay as they are. Name it for what it is: an episode, a draft, a story.",
-    inputSchema: { name: z.string().optional() },
+      "Add a board to the project and open it: an empty wall with the logline placeholder, under the same premise, with the same target length as the board that was open. Nothing else is touched — the other boards stay as they are. Name it for what it is: an episode, a draft, a story; or pass open with the writer's words for why the name is not decided, and it is born open on its name.",
+    inputSchema: { name: z.string().optional(), open: z.string().optional() },
   },
   async (args) => {
     const { project, boards, rev, base } = await readProject();
     const previous = boards[project.activeBoardId];
     const target =
       previous && isBoardState(previous) ? normalizeState(previous).targetEighths : undefined;
-    const { project: next, board } = addBoard(project, args.name ?? "");
+    const { project: next, board } = addBoard(project, args.name ?? "", undefined, args.open ?? "");
     const fresh = { ...emptyState(), ...(target ? { targetEighths: target } : {}) };
     const { live } = await openBoardEverywhere(next, { ...boards, [board.id]: fresh }, rev, base, board.id);
     return ok(
-      `Added "${board.name}" (${board.id}) and opened it${where(live)}: every card call lands there now, and the writer's open wall switched with it; open_board ${project.boards.findIndex((item) => item.id === project.activeBoardId) + 1} returns to "${project.boards.find((item) => item.id === project.activeBoardId)?.name ?? "the one before"}". It is empty, and the project's cast is already there to cast from. The logline is the story's question when the writer has one — leave it empty rather than invent it — and the cards come next.${next.name === "Untitled project" ? " The project is still \"Untitled project\": rename_project names it." : ""}${next.boards.length === 2 && isSampleWall(isBoardState(boards[next.boards[0].id]) ? normalizeState(boards[next.boards[0].id]) : emptyState()) ? " The sample stays as Board 1; delete_board drops it." : ""}`,
+      `Added "${board.name}" (${board.id})${board.nameOpen ? ` — its name left open, by the writer's word: "${board.nameOpen}"` : ""} and opened it${where(live)}: every card call lands there now, and the writer's open wall switched with it; open_board ${project.boards.findIndex((item) => item.id === project.activeBoardId) + 1} returns to "${project.boards.find((item) => item.id === project.activeBoardId)?.name ?? "the one before"}". It is empty, and the project's cast is already there to cast from. The logline is the story's question when the writer has one — leave it empty rather than invent it — and the cards come next.${next.name === "Untitled project" ? " The project is still \"Untitled project\": rename_project names it." : ""}${next.boards.length === 2 && isSampleWall(isBoardState(boards[next.boards[0].id]) ? normalizeState(boards[next.boards[0].id]) : emptyState()) ? " The sample stays as Board 1; delete_board drops it." : ""}`,
       board,
     );
   },
@@ -3916,17 +3957,25 @@ server.registerTool(
   "rename_board",
   {
     title: "Rename board",
-    description: "Rename a board of the project by id, name, or number.",
-    inputSchema: { board: z.union([z.string().min(1), z.number()]), name: z.string().min(1) },
+    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.",
+    inputSchema: { board: z.union([z.string().min(1), z.number()]), 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 name is not decided).");
     const { project, boards, rev, base } = await readProject();
     const target = findBoard(project, String(args.board));
     if (!target) return ok(`No board matches "${args.board}". Call list_boards for the real ones.`);
+    if (args.name === undefined) {
+      const next = setBoardNameOpen(project, target.id, args.open);
+      if (next === project) return ok(`"${target.name}" already reads that way.`);
+      const live = await writeProject(next, boards, rev, base);
+      const words = boardById(next, target.id)?.nameOpen ?? "";
+      return ok(words ? `Board "${target.name}" (${target.id}) keeps its name and its name is left open, by the writer's word: "${words}"${where(live)}. The reading lists it; rename_board with a name decides it.` : `Board "${target.name}" (${target.id}) is no longer open on its name${where(live)}.`, { id: target.id, name: target.name, nameOpen: words });
+    }
     const next = renameBoard(project, target.id, args.name);
     if (next === project) return ok(`"${target.name}" already has that name.`);
     const live = await writeProject(next, boards, rev, base);
-    return ok(`Renamed board "${target.name}" (${target.id}) to "${args.name.trim()}"${where(live)}.`, { id: target.id, name: args.name.trim() });
+    return ok(`Renamed board "${target.name}" (${target.id}) to "${args.name.trim()}"${where(live)}.${target.nameOpen ? " Its name is decided; the open words are gone." : ""}`, { id: target.id, name: args.name.trim() });
   },
 );
 

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), 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 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.",
   ],
   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

@@ -122,8 +122,9 @@ export function toFountain(state, options = {}) {
     const revisionMarksFor = (_list, card) => Boolean(revisionOf.get(card.id)?.revised);
     const cast = (note.characterIds ?? []).map((id) => nameOf.get(id)).filter(Boolean);
     if (cast.length) marks.push(`with ${cast.join(", ")}`);
-    if (note.plants) marks.push("plants something to pay off later");
+    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.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(", ")}`);
     if (revisionMarksFor(marks, note)) marks.push(`changed in the ${state.revision.color} revision`);

package/src/board/project.d.ts

@@ -8,6 +8,8 @@ export declare const DEFAULT_PROJECT_NAME: string;
 export type BoardMeta = {
   id: string;
   name: string;
+  /** The writer's words for why the name is not decided (R61), or empty; the name stands meanwhile. */
+  nameOpen: string;
   createdAt: string;
   updatedAt: string;
 };
@@ -18,6 +20,8 @@ export type ProjectRecord = {
   id: string;
   name: string;
   premise: string;
+  /** The writer's words for why there is no premise yet (R61), or empty. */
+  premiseOpen: string;
   boards: BoardMeta[];
   activeBoardId: string;
   /** A writer's own structures, saved from a wall's beats (Roadmap 2, item 7). */
@@ -41,7 +45,7 @@ export declare function addStructure(
 ): { project: ProjectRecord; structure: OwnStructure };
 export declare function removeStructure(project: ProjectRecord, id: string, now?: string): ProjectRecord;
 
-export declare function newBoardMeta(name: string, now?: string): BoardMeta;
+export declare function newBoardMeta(name: string, now?: string, nameOpen?: string): BoardMeta;
 export declare function emptyProject(now?: string): ProjectRecord;
 export declare function isProjectRecord(value: unknown): value is ProjectRecord;
 export declare function normalizeProject(value: unknown, now?: string): ProjectRecord;
@@ -49,6 +53,7 @@ export declare function addBoard(
   project: ProjectRecord,
   name: string,
   now?: string,
+  nameOpen?: string,
 ): { project: ProjectRecord; board: BoardMeta };
 export declare function renameBoard(
   project: ProjectRecord,
@@ -66,6 +71,10 @@ export declare function moveBoard(
 export declare function setActiveBoard(project: ProjectRecord, id: string, now?: string): ProjectRecord;
 export declare function renameProject(project: ProjectRecord, name: string, now?: string): ProjectRecord;
 export declare function setPremise(project: ProjectRecord, premise: string, now?: string): ProjectRecord;
+/** The writer's words for why there is no premise yet (R61); words clear the premise, "" takes them back. */
+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;
 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

@@ -18,8 +18,13 @@ function trimmed(value, fallback) {
   return typeof value === "string" && value.trim() ? value.trim() : fallback;
 }
 
-export function newBoardMeta(name, now = nowIso()) {
-  return { id: newId(), name: trimmed(name, "Board"), createdAt: now, updatedAt: now };
+export function newBoardMeta(name, now = nowIso(), nameOpen = "") {
+  return { id: newId(), name: trimmed(name, "Board"), nameOpen: openWords(nameOpen), createdAt: now, updatedAt: now };
+}
+
+/** The writer's words for why a field is not decided (R61), one line, spaces collapsed; empty is decided or blank. */
+function openWords(value) {
+  return typeof value === "string" ? value.trim().replace(/\s+/g, " ") : "";
 }
 
 export function emptyProject(now = nowIso()) {
@@ -29,6 +34,7 @@ export function emptyProject(now = nowIso()) {
     id: newId(),
     name: DEFAULT_PROJECT_NAME,
     premise: "",
+    premiseOpen: "",
     boards: [board],
     activeBoardId: board.id,
     createdAt: now,
@@ -60,6 +66,8 @@ export function normalizeProject(value, now = nowIso()) {
   const boards = value.boards.filter(isBoardMeta).map((board) => ({
     ...board,
     name: trimmed(board.name, "Board"),
+    // A board named before R61 has no open name; the name stands until the writer says it is not decided.
+    nameOpen: openWords(board.nameOpen),
     createdAt: typeof board.createdAt === "string" ? board.createdAt : now,
     updatedAt: typeof board.updatedAt === "string" ? board.updatedAt : now,
   }));
@@ -80,6 +88,8 @@ export function normalizeProject(value, now = nowIso()) {
     version: PROJECT_VERSION,
     name: trimmed(value.name, DEFAULT_PROJECT_NAME),
     premise: typeof value.premise === "string" ? value.premise.trim() : "",
+    // A project written before R61 has no open premise (R61).
+    premiseOpen: openWords(value.premiseOpen),
     boards,
     activeBoardId,
     structures,
@@ -261,9 +271,9 @@ function touch(project, patch, now) {
 }
 
 /** Add a board after the others and open it. Returns the project and the new board. */
-export function addBoard(project, name, now = nowIso()) {
+export function addBoard(project, name, now = nowIso(), nameOpen = "") {
   const fallback = `Board ${project.boards.length + 1}`;
-  const board = newBoardMeta(trimmed(name, fallback), now);
+  const board = newBoardMeta(trimmed(name, fallback), now, nameOpen);
   return {
     project: touch(project, { boards: [...project.boards, board], activeBoardId: board.id }, now),
     board,
@@ -275,9 +285,26 @@ export function renameBoard(project, id, name, now = nowIso()) {
   if (!next) return project;
   let changed = false;
   const boards = project.boards.map((board) => {
-    if (board.id !== id || board.name === next) return board;
+    if (board.id !== id || (board.name === next && !(board.nameOpen ?? ""))) return board;
     changed = true;
-    return { ...board, name: next, updatedAt: now };
+    // A name decides the field: the open words go (R61).
+    return { ...board, name: next, nameOpen: "", updatedAt: now };
+  });
+  return changed ? touch(project, { boards }, now) : project;
+}
+
+/**
+ * The writer's words for why a board's name is not decided (R61), or "" to
+ * take them back. The name stands as it is — "Board 1" is still what every
+ * reply calls it — but the reading lists the words and the crumb draws them.
+ */
+export function setBoardNameOpen(project, id, words, now = nowIso()) {
+  const next = openWords(words);
+  let changed = false;
+  const boards = project.boards.map((board) => {
+    if (board.id !== id || (board.nameOpen ?? "") === next) return board;
+    changed = true;
+    return { ...board, nameOpen: next, updatedAt: now };
   });
   return changed ? touch(project, { boards }, now) : project;
 }
@@ -321,8 +348,18 @@ export function renameProject(project, name, now = nowIso()) {
 
 export function setPremise(project, premise, now = nowIso()) {
   const next = typeof premise === "string" ? premise.trim() : "";
-  if (next === project.premise) return project;
-  return touch(project, { premise: next }, now);
+  // A premise decides the field: the open words go (R61); clearing it leaves them.
+  const premiseOpen = next ? "" : (project.premiseOpen ?? "");
+  if (next === project.premise && premiseOpen === (project.premiseOpen ?? "")) return project;
+  return touch(project, { premise: next, premiseOpen }, now);
+}
+
+/** The writer's words for why there is no premise yet (R61), or "" to take them back; words clear the premise. */
+export function setPremiseOpen(project, words, now = nowIso()) {
+  const next = openWords(words);
+  const premise = next ? "" : project.premise;
+  if (next === (project.premiseOpen ?? "") && premise === project.premise) return project;
+  return touch(project, { premise, premiseOpen: next }, now);
 }
 
 /**

package/src/board/readWall.d.ts

@@ -71,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[] }>;
+  /** 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 }>;
   /** 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. */

package/src/board/readWall.js

@@ -420,7 +420,7 @@ export function readWall(state, options = {}) {
       findings.push({
         kind: "unpaid",
         ids: [note.id],
-        text: `${quote(note)} plants something, and no arrow pays it off. Where does it come back?`,
+        text: `${quote(note)} plants ${note.plantsWhat || "something"}, and no arrow pays it off. Where does ${note.plantsWhat ? "it" : "it"} come back?`.replace("Where does it come back?", note.plantsWhat ? `Where ${/s$/i.test(note.plantsWhat) ? "do" : "does"} ${note.plantsWhat} come back?` : "Where does it come back?"),
       });
     }
   }
@@ -557,6 +557,7 @@ export function readWall(state, options = {}) {
     later,
     paidBy: paidHere,
     open: describeOpen(state, options, order, openIds),
+    openFields: describeOpenFields(state, order),
     threads,
     findings: asked,
     left,
@@ -568,6 +569,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 fields the writer has left open (R61), in the writer's words: the
+ * board's logline, and a card's when, in story order. The premise and the
+ * board's name live on the project, and the door adds them. Listed, never
+ * asked about: no check asks about a missing logline or when.
+ */
+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.whenOpen ?? "").trim()) fields.push({ field: "when", id: note.id, words: note.whenOpen.trim() });
+  return fields;
+}
+
 /** 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"]);
 
@@ -600,7 +614,8 @@ export function describeSetups(reading, state) {
         : setup.eighths === 0
           ? "in the same place on the wall"
           : `about ${pages(-setup.eighths)} pages earlier`;
-    return `"${name(setup.from)}" sets up "${name(setup.to)}", ${distance}`;
+    const what = byId.get(setup.from)?.plantsWhat ?? "";
+    return `"${name(setup.from)}" sets up "${name(setup.to)}"${what ? ` — ${what}` : ""}, ${distance}`;
   });
 }
 

package/src/board/reducer.d.ts

@@ -79,6 +79,8 @@ export type BoardNote = {
   characterIds: string[];
   /** The corner is folded: this card plants something that must pay off (R31). */
   plants: boolean;
+  /** What the fold plants, in the writer's words (R62), or empty; never set on an unfolded card. */
+  plantsWhat: string;
   /** When folded: the id of another board of the project where it pays off (R50), or null. */
   payoffBoardId: string | null;
   /** The scene on that board that pays it off (R58), or null while the board is only a promise. */
@@ -89,6 +91,8 @@ export type BoardNote = {
   location: string;
   /** When the scene happens, as the writer says it — "night", "day four, dawn" — printed after the place on the heading (R55). Empty when unsaid. */
   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 scene's text in Fountain (R23 b): action, cues, dialogue; empty until written. */
   text: string;
   createdAt: string;
@@ -112,6 +116,8 @@ export type BoardArrow = {
 export type BoardState = {
   /** The board's central question — what this story is arguing (R19). */
   logline: string;
+  /** The writer's words for why there is no logline yet (R61), or empty. */
+  loglineOpen: string;
   /** Target script length in eighths of a page; 120 pages for a feature (R25). */
   targetEighths: number;
   /** The roster: every person in the story, whether or not they are on a card yet (R29). */
@@ -158,7 +164,7 @@ export declare function fillCharacter(character: { id: string; name: string } &
 export declare function sameName(a: string, b: string): boolean;
 
 export type Command =
-  | { type: "set_logline"; logline: string }
+  | { type: "set_logline"; logline?: string; open?: string }
   | { type: "set_rank"; ids: string[]; rank: NoteRank }
   | { type: "set_length"; ids: string[]; lengthEighths: number | null }
   | { type: "set_target"; targetEighths: number }
@@ -175,8 +181,11 @@ export type Command =
       lengthEighths?: number;
       characterIds?: string[];
       plants?: boolean;
+      /** What it plants, in the writer's words (R62); naming a plant folds the card. */
+      plantsWhat?: string;
       location?: string;
       when?: string;
+      whenOpen?: string;
       open?: string;
       text?: string;
     }
@@ -204,11 +213,11 @@ export type Command =
   | { type: "remove_character"; id: string }
   | ({ type: "update_character"; id: string } & Partial<Record<CharacterField, string>>)
   | { type: "set_cast"; ids: string[]; characterIds: string[] }
-  | { type: "set_plant"; ids: string[]; plants: boolean }
+  | { type: "set_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_when"; ids: string[]; when: 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 }
   | { type: "lock_numbers"; order?: string[] }

package/src/board/reducer.js

@@ -220,6 +220,7 @@ export function emptyState() {
   return {
     logline: "",
     targetEighths: DEFAULT_TARGET_EIGHTHS,
+    loglineOpen: "",
     characters: [],
     notes: [],
     groups: [],
@@ -247,8 +248,12 @@ export function seedState(now = nowIso()) {
     characterIds,
     location: "",
     when: "",
+    // The writer's words for why the when is not decided (R61), or nothing.
+    whenOpen: "",
     text: "",
     plants: false,
+    // What the fold plants, in the writer's words (R62), or nothing.
+    plantsWhat: "",
     // A fold that pays off on another board — a later episode — names it here;
     // null claims nothing (R50). The scene there that pays it off, once one
     // does (R58); null while the board is a promise.
@@ -267,6 +272,7 @@ export function seedState(now = nowIso()) {
     // new writer finds out the logline is there at all.
     logline: "",
     targetEighths: DEFAULT_TARGET_EIGHTHS,
+    loglineOpen: "",
     // Two people, cast on the cards, so a new writer sees what the roster is for.
     characters: [
       fillCharacter({ id: "maya", name: "Maya", createdAt: now, updatedAt: now }),
@@ -352,6 +358,8 @@ export function normalizeState(value) {
     const characterIds = knownCast(note?.characterIds, characters);
     // Cards written before R31 have no fold; a plant is a claim you make.
     const plants = note?.plants === true;
+    // Cards folded before R62 say "something": the fold's words are the writer's, or nothing.
+    const plantsWhat = plants && typeof note?.plantsWhat === "string" ? note.plantsWhat : "";
     // Cards written before R50 pay off on their own board or not at all.
     const payoffBoardId = plants && typeof note?.payoffBoardId === "string" && note.payoffBoardId ? note.payoffBoardId : null;
     // Cards written before R58 name a board and no scene on it.
@@ -362,6 +370,8 @@ export function normalizeState(value) {
     const location = typeof note?.location === "string" ? note.location : "";
     // 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.
+    const whenOpen = typeof note?.whenOpen === "string" ? note.whenOpen : "";
     // Cards written before pages (R23 b) have no text; a scene is unwritten until it is.
     const text = typeof note?.text === "string" ? note.text : "";
     if (
@@ -371,17 +381,19 @@ export function normalizeState(value) {
       Array.isArray(note.characterIds) &&
       sameIds(note.characterIds, characterIds) &&
       note.plants === plants &&
+      note.plantsWhat === plantsWhat &&
       note.payoffBoardId === payoffBoardId &&
       note.payoffNoteId === payoffNoteId &&
       note.open === open &&
       note.location === location &&
       note.when === when &&
+      note.whenOpen === whenOpen &&
       note.text === text
     ) {
       return note;
     }
     patched = true;
-    return { ...note, rank, lengthEighths, characterIds, plants, payoffBoardId, payoffNoteId, open, location, when, text };
+    return { ...note, rank, lengthEighths, characterIds, plants, plantsWhat, payoffBoardId, payoffNoteId, open, location, when, whenOpen, text };
   });
 
   // Boards written before the production half (Roadmap 2, item 8) have no
@@ -411,8 +423,11 @@ export function normalizeState(value) {
       return { ...thread, noteIds, startOpen, endOpen };
     })
     .filter(Boolean);
+  // Boards written before R61 have no open logline; a logline is decided or blank until the writer says otherwise.
+  const loglineOpen = typeof value.loglineOpen === "string" ? value.loglineOpen : "";
   if (
     value.logline === logline &&
+    value.loglineOpen === loglineOpen &&
     value.targetEighths === targetEighths &&
     !rosterPatched &&
     !arrowsPatched &&
@@ -427,6 +442,7 @@ export function normalizeState(value) {
   return {
     ...value,
     logline,
+    loglineOpen,
     targetEighths,
     characters,
     notes: patched ? notes : value.notes,
@@ -458,6 +474,48 @@ function cleanOpen(value) {
   return typeof value === "string" ? value.trim().replace(/\s+/g, " ") : "";
 }
 
+/**
+ * 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
+ * that is the fold's and the setup arrow's to draw: when the first card's
+ * fold is free — unfolded, or folded for the same thing, or folded with no
+ * words — the card is folded, the fold takes the thread's name, and a setup
+ * arrow runs from the first card to the last. When the first card's fold is
+ * another thing's, the thread stays a thread and nothing is drawn. Returns
+ * the state and what it did, so the door can say it.
+ */
+function tieIntoFold(state, thread, now) {
+  const none = { state, fold: null };
+  if (thread.startOpen || thread.endOpen || thread.noteIds.length < 2) return none;
+  const firstId = thread.noteIds[0];
+  const lastId = thread.noteIds[thread.noteIds.length - 1];
+  const first = state.notes.find((note) => note.id === firstId);
+  if (!first) return none;
+  const what = first.plantsWhat ?? "";
+  if (first.plants && what && what.toLowerCase() !== thread.name.toLowerCase()) {
+    return { state, fold: { kept: true, firstId, what } };
+  }
+  let next = state;
+  const folded = !first.plants;
+  const named = !what;
+  if (folded || named) {
+    next = {
+      ...next,
+      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);
+  let arrow = null;
+  if (!hasArrow) {
+    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 } };
+}
+
 /** 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, " ") : "";
@@ -474,10 +532,15 @@ function pruneGroups(groups) {
 
 export function applyCommand(state, command, now = nowIso()) {
   switch (command.type) {
+    // The logline, or the writer's words for why there is none yet (R61): a
+    // value clears the open words, open words clear the value, and open ""
+    // leaves the field blank.
     case "set_logline": {
-      const logline = typeof command.logline === "string" ? command.logline.trim() : "";
-      if (logline === (state.logline ?? "")) return { state, changed: false };
-      return { state: { ...state, logline }, changed: true, result: { logline } };
+      const hasOpen = typeof command.open === "string";
+      const logline = hasOpen && command.open.trim() ? "" : typeof command.logline === "string" ? command.logline.trim() : (state.logline ?? "");
+      const loglineOpen = hasOpen ? cleanOpen(command.open) : logline ? "" : (state.loglineOpen ?? "");
+      if (logline === (state.logline ?? "") && loglineOpen === (state.loglineOpen ?? "")) return { state, changed: false };
+      return { state: { ...state, logline, loglineOpen }, changed: true, result: { logline, loglineOpen } };
     }
 
     case "create_note": {
@@ -496,12 +559,15 @@ export function applyCommand(state, command, now = nowIso()) {
             ? null
             : clampEighths(command.lengthEighths, DEFAULT_NOTE_EIGHTHS, MAX_NOTE_EIGHTHS),
         characterIds: knownCast(command.characterIds, state.characters ?? []),
-        plants: command.plants === true,
+        plants: command.plants === true || Boolean(cleanOpen(command.plantsWhat)),
+        // What it plants, in the writer's words (R62): naming a plant folds the card.
+        plantsWhat: command.plants === false ? "" : cleanOpen(command.plantsWhat),
         payoffBoardId: null,
         payoffNoteId: null,
         open: cleanOpen(command.open),
         location: cleanPlace(command.location),
-        when: cleanWhen(command.when),
+        when: cleanOpen(command.whenOpen) ? "" : cleanWhen(command.when),
+        whenOpen: cleanOpen(command.whenOpen),
         text: typeof command.text === "string" ? command.text : "",
         z: maxZ(state.notes) + 1,
         createdAt: now,
@@ -751,7 +817,8 @@ export function applyCommand(state, command, now = nowIso()) {
         startOpen: command.startOpen === true,
         endOpen: command.endOpen === true,
       };
-      return { state: { ...state, threads: [...(state.threads ?? []), thread] }, changed: true, result: thread };
+      const tied = tieIntoFold({ ...state, threads: [...(state.threads ?? []), thread] }, thread, now);
+      return { state: tied.state, changed: true, result: { ...thread, fold: tied.fold } };
     }
 
     case "update_thread": {
@@ -768,10 +835,17 @@ export function applyCommand(state, command, now = nowIso()) {
         return { state, changed: false };
       }
       const next = { ...current, name, noteIds, startOpen, endOpen };
+      // A fold this thread named follows a rename (R62), so the two never drift apart on the wall's word alone.
+      let notes = state.notes;
+      if (name !== current.name && noteIds.length) {
+        const firstId = noteIds[0];
+        notes = notes.map((note) => (note.id === firstId && note.plants && (note.plantsWhat ?? "").toLowerCase() === current.name.toLowerCase() ? bump(note, { plantsWhat: name }, now) : note));
+      }
+      const tied = tieIntoFold({ ...state, notes, threads: state.threads.map((thread) => (thread.id === command.id ? next : thread)) }, next, now);
       return {
-        state: { ...state, threads: state.threads.map((thread) => (thread.id === command.id ? next : thread)) },
+        state: tied.state,
         changed: true,
-        result: { thread: next, before: current },
+        result: { thread: next, before: current, fold: tied.fold },
       };
     }
 
@@ -1010,11 +1084,13 @@ export function applyCommand(state, command, now = nowIso()) {
         lengthEighths: null,
         characterIds: [],
         plants: false,
+        plantsWhat: "",
         payoffBoardId: null,
         payoffNoteId: null,
         open: "",
         location: "",
         when: "",
+        whenOpen: "",
         text: "",
         createdAt: now,
         updatedAt: now,
@@ -1121,11 +1197,21 @@ export function applyCommand(state, command, now = nowIso()) {
     case "set_when": {
       const ids = new Set(command.ids);
       if (ids.size === 0) return { state, changed: false };
-      const when = cleanWhen(command.when);
+      // The when, or the writer's words for why there is none yet (R61): a
+      // value clears the open words, open words clear the value, open "" leaves
+      // the when blank.
+      const hasOpen = typeof command.open === "string";
+      const whenOpen = hasOpen ? cleanOpen(command.open) : null;
+      const when = hasOpen ? (whenOpen ? "" : typeof command.when === "string" ? cleanWhen(command.when) : null) : cleanWhen(command.when);
       const touched = [];
       const notes = state.notes.map((note) => {
-        if (!ids.has(note.id) || note.when === when) return note;
-        const next = bump(note, { when }, now);
+        if (!ids.has(note.id)) return note;
+        const patch = {
+          when: when === null ? (note.when ?? "") : when,
+          whenOpen: whenOpen === null ? (when ? "" : (note.whenOpen ?? "")) : whenOpen,
+        };
+        if (patch.when === (note.when ?? "") && patch.whenOpen === (note.whenOpen ?? "")) return note;
+        const next = bump(note, patch, now);
         touched.push(next);
         return next;
       });
@@ -1155,15 +1241,20 @@ export function applyCommand(state, command, now = nowIso()) {
     case "set_plant": {
       const ids = new Set(command.ids);
       if (ids.size === 0) return { state, changed: false };
-      const plants = command.plants === true;
+      // What the fold plants, in the writer's words (R62): `what` names it and
+      // folds an unfolded card; `plants` alone keeps the words; unfolding
+      // forgets them, as it forgets where it paid off.
+      const what = typeof command.what === "string" ? cleanOpen(command.what) : null;
       const touched = [];
       const notes = state.notes.map((note) => {
         if (!ids.has(note.id)) return note;
+        const plants = typeof command.plants === "boolean" ? command.plants : note.plants || Boolean(what);
+        const plantsWhat = !plants ? "" : what === null ? (note.plantsWhat ?? "") : what;
         // Unfolding forgets where it paid off; a claim that no longer stands.
         const payoffBoardId = plants ? note.payoffBoardId : null;
         const payoffNoteId = plants ? (note.payoffNoteId ?? null) : null;
-        if (note.plants === plants && note.payoffBoardId === payoffBoardId && note.payoffNoteId === payoffNoteId) return note;
-        const next = bump(note, { plants, payoffBoardId, payoffNoteId }, now);
+        if (note.plants === plants && (note.plantsWhat ?? "") === plantsWhat && note.payoffBoardId === payoffBoardId && note.payoffNoteId === payoffNoteId) return note;
+        const next = bump(note, { plants, plantsWhat, payoffBoardId, payoffNoteId }, 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.",
+        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.",
       },
       {
         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. The card says unpaid, and the bar’s Asks line keeps asking, 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 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.",
         target: "corner",
       },
       {

package/src/board/workflows.js

@@ -24,15 +24,15 @@ export const WORKFLOWS = [
     // an agent asks the ones the treatment leaves open, and invents none.
     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: "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: "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: "When does a scene happen, where that matters?", hint: "That night; the fourth of October. It goes beside the place, never in the headline. Not decided: set_when with open and the writer's words, and the card is still asked about the rest.", 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. 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 are the project and the board called?", hint: "The series, and this episode. A board's name not decided: rename_board, new_project and new_board take open with the writer's words.", 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" },
     ],
   },