plotcoder-board 0.1.31 → 0.1.33

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.31. 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.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.

package/package.json

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

package/scripts/plotcoder-mcp-server.mjs

@@ -1059,7 +1059,8 @@ 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];
@@ -1384,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,
@@ -1428,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,
@@ -2783,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;
@@ -2823,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 });
@@ -2851,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,
     );
   },
@@ -3180,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";
@@ -3208,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,
     );
   },
@@ -3250,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,
     );
   },

package/src/board/fountain.js

@@ -122,7 +122,7 @@ 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);

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?"),
       });
     }
   }
@@ -614,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. */
@@ -179,6 +181,8 @@ 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;
@@ -209,7 +213,7 @@ 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 }

package/src/board/reducer.js

@@ -252,6 +252,8 @@ export function seedState(now = nowIso()) {
     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.
@@ -356,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.
@@ -377,6 +381,7 @@ 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 &&
@@ -388,7 +393,7 @@ export function normalizeState(value) {
       return note;
     }
     patched = true;
-    return { ...note, rank, lengthEighths, characterIds, plants, payoffBoardId, payoffNoteId, open, location, when, whenOpen, 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
@@ -469,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, " ") : "";
@@ -512,7 +559,9 @@ 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),
@@ -768,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": {
@@ -785,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 },
       };
     }
 
@@ -1027,6 +1084,7 @@ export function applyCommand(state, command, now = nowIso()) {
         lengthEighths: null,
         characterIds: [],
         plants: false,
+        plantsWhat: "",
         payoffBoardId: null,
         payoffNoteId: null,
         open: "",
@@ -1183,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

@@ -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",
       },
       {