plotcoder-board 0.1.11 → 0.1.13

package/package.json

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

package/scripts/plotcoder-mcp-server.mjs

@@ -52,6 +52,7 @@ import { DEFAULT_REMINDERS, titleFromBody } from "../src/board/reminders.js";
 import crypto from "node:crypto";
 import { describeRuns, describeSetups, readWall } from "../src/board/readWall.js";
 import { GAP, ROW_WIDTH, organizePoses } from "../src/board/organize.js";
+import { sceneLineCount } from "../src/board/paginate.js";
 import {
   addBoard,
   addStructure,
@@ -434,14 +435,16 @@ async function accountReadProject() {
   const { data, error } = await accountDoor.client.from("projects").select("id, record, reminders, rev").eq("id", accountDoor.projectId).maybeSingle();
   if (error || !data || !isProjectRecord(data.record)) throw new Error(error?.message ?? "the project is gone from the account");
   const project = normalizeProject(data.record);
-  const rows = await accountDoor.client.from("boards").select("id, state, rev").eq("project_id", project.id);
+  const rows = await accountDoor.client.from("boards").select("id, state, rev, updated_at").eq("project_id", project.id);
   const boards = {};
   const revs = {};
+  const changedAt = {};
   for (const row of rows.data ?? []) {
     if (isBoardState(row.state)) boards[row.id] = normalizeState(row.state);
     revs[row.id] = row.rev;
+    if (row.updated_at) changedAt[row.id] = row.updated_at;
   }
-  return { project, boards, revs, reminders: Array.isArray(data.reminders) ? data.reminders : null, rev: data.rev, base: ACCOUNT, live: ACCOUNT };
+  return { project, boards, revs, changedAt, reminders: Array.isArray(data.reminders) ? data.reminders : null, rev: data.rev, base: ACCOUNT, live: ACCOUNT };
 }
 
 async function accountWriteProject(project, boards, rev, reminders) {
@@ -786,7 +789,7 @@ const CHECK_WORDS = {
   unwritten: "no card without a headline or change line",
   unlinked: "no card without an arrow",
   duplicate: "no two headlines alike",
-  sequence: "no group too long for one sequence",
+  sequence: "no group too long for one sequence (act groups are not asked)",
   uncast: "nobody in the cast on no card",
   absent: "nobody gone for a third of the story",
   backwards: "no payoff before its setup",
@@ -803,11 +806,13 @@ function summarize(state) {
     .map((note) => {
       const cast = note.characterIds.map((id) => nameOf.get(id) ?? id);
       const who = cast.length ? `, cast: ${cast.join(", ")}` : "";
-      const plant = note.plants ? ", plants" : "";
+      const plant = note.plants ? (note.payoffBoardId ? ", plants → pays off later" : ", plants") : "";
+      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 count = formatPages(noteEighths(note));
-      const pages = `${count} ${count === "1" ? "page" : "pages"}${isMeasured(note) ? ", written" : note.lengthEighths === null ? ", unsized" : ""}`;
-      return `  - ${note.id} [${note.rank ?? "scene"}, ${pages}${who}${place}${plant}] — "${note.headline}" (${note.color}) at ${Math.round(note.x)},${Math.round(note.y)}`;
+      const pages = isMeasured(note) ? `${count} ${count === "1" ? "page" : "pages"}, written` : note.lengthEighths === null ? "about a page, unsized" : `${count} ${count === "1" ? "page" : "pages"}`;
+      return `  - ${note.id} [${note.rank ?? "scene"}, ${pages}${who}${place}${plant}${revised}] — "${note.headline}" (${note.color}) at ${Math.round(note.x)},${Math.round(note.y)}`;
     })
     .join("\n");
   const cast = state.characters
@@ -841,7 +846,9 @@ function summarize(state) {
         `  - ${group.id} — "${group.title}" holds ${group.noteIds.length}: ${group.noteIds.join(", ")}`,
     )
     .join("\n");
-  const arrows = state.arrows
+  const storyIndex = new Map(readingOrder(state.notes).map((note, index) => [note.id, index]));
+  const arrows = [...state.arrows]
+    .sort((a, b) => (storyIndex.get(a.from) ?? Infinity) - (storyIndex.get(b.from) ?? Infinity) || (a.kind === "setup") - (b.kind === "setup"))
     .map(
       (arrow) =>
         `  - ${arrow.id} [${arrow.kind ?? "follows"}] — ${arrow.from} → ${arrow.to}  ("${headline(arrow.from)}" ${arrow.kind === "setup" ? "sets up" : "→"} "${headline(arrow.to)}")`,
@@ -931,7 +938,7 @@ server.registerTool(
       : "board";
     return ok(
       `PlotCoder ${which} (${door(live, base)})\n${summarize(state)}`,
-      state,
+      { ...state, revision: state.revision ? { name: state.revision.name, color: state.revision.color, since: state.revision.since } : null, notes: state.notes.map((note) => ({ ...note, eighths: noteEighths(note), measured: isMeasured(note) })) },
     );
   },
 );
@@ -976,7 +983,7 @@ server.registerTool(
     });
     const { beats, scenes } = countRanks(state);
     return ok(
-      `${result?.length ?? 0} card(s) are now ${args.rank}${where(live)}. The board holds ${beats} beats and ${scenes} scenes.`,
+      `${result?.length ?? 0} card(s) are now ${args.rank}${where(live)}. The board holds ${beats} beats and ${scenes} scenes. The rows are as they were; organize lays a row per beat.`,
       result,
     );
   },
@@ -1000,7 +1007,7 @@ server.registerTool(
       lengthEighths: toEighths(args.pages),
     });
     return ok(
-      `${result?.length ?? 0} card(s) now run about ${args.pages} page(s)${where(live)}. The board runs about ${formatPages(boardEighths(state))} pages against a ${formatPages(state.targetEighths)}-page target.`,
+      `${result?.length ?? 0} card(s) now run ${args.pages} page(s), the writer's estimate${where(live)}. The board runs about ${formatPages(boardEighths(state))} pages against a ${formatPages(state.targetEighths)}-page target.`,
       result,
     );
   },
@@ -1112,7 +1119,7 @@ server.registerTool(
     },
   },
   async (args) => {
-    const { result } = await commit({
+    const { state, result, live } = await commit({
       type: "update_note",
       id: args.id,
       headline: args.headline,
@@ -1120,7 +1127,8 @@ server.registerTool(
       location: args.location,
     });
     if (result === undefined) return ok(`No card with id ${args.id}.`);
-    return ok("Updated card.", result);
+    const mark = state.revision && state.revision.snapshot?.[result.id] && (state.revision.snapshot[result.id].headline !== result.headline || state.revision.snapshot[result.id].change !== result.change) ? ` Marked changed in the ${state.revision.color} revision "${state.revision.name}".` : "";
+    return ok(`Updated "${result.headline}"${args.change !== undefined ? `: change line "${result.change}"` : ""}${where(live)}.${mark}`, result);
   },
 );
 
@@ -1184,7 +1192,9 @@ server.registerTool(
     inputSchema: {},
   },
   async () => {
-    const { state, live, base } = await readBoard();
+    const { state, live, base, boardId: readBoardId } = await readBoard();
+    const { project: projectForRead } = await readProject();
+    const readBoardMeta = boardById(projectForRead, readBoardId ?? projectForRead.activeBoardId);
     const reading = readWall(state);
     const runs = describeRuns(reading, state).map((line, index) => {
       const ids = reading.runs[index]?.ids ?? [];
@@ -1194,6 +1204,8 @@ server.registerTool(
     const written = state.notes.filter((note) => isMeasured(note)).length;
     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 ? ` — ${projectForRead.boards.length} boards in "${projectForRead.name}"; open_board reads another` : ""}`,
       `logline: ${state.logline ? `"${state.logline}"` : "(none yet)"}`,
       "the cast and the places are list_board's, not the reading's",
       state.targetEighths === DEFAULT_TARGET_EIGHTHS
@@ -1222,17 +1234,23 @@ server.registerTool(
       ...(reading.setups.length
         ? describeSetups(reading, state).map((line) => `  - ${line}`)
         : ["  (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}"`),
       "questions the wall raises:",
       ...(reading.findings.length
         ? reading.findings.map((finding) => `  - [${finding.kind}] ${finding.text}${finding.ids.length ? ` (ids: ${finding.ids.join(", ")})` : ""}`)
         : ["  (none that this reading can see)"]),
       `checks: ${CHECKS.length} run — ${(() => {
-        const asked = reading.findings.filter((finding) => CHECKS.includes(finding.kind));
+        const asked = reading.findings;
         if (asked.length === 0) return "asking nothing";
         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(", ")}`;
-      })()}; checked and clean: ${CHECKS.filter((kind) => !reading.findings.some((finding) => finding.kind === kind)).map((kind) => CHECK_WORDS[kind]).join("; ") || "(nothing — every check found something)"}`,
+      })()}; checked and clean: ${CHECKS.filter((kind) => !reading.findings.some((finding) => finding.kind === kind)).map((kind) => {
+        if (kind === "unlinked" && state.arrows.length === 0) return "no card without an arrow (not asked: no arrows yet)";
+        if (kind === "unplaced" && !state.notes.some((note) => (note.location ?? "").trim())) return "no card without a place (not asked: no card placed yet)";
+        if (kind === "sequence" && state.groups.length === 0) return "no group too long for one sequence (not asked: no groups)";
+        return CHECK_WORDS[kind];
+      }).join("; ") || "(nothing — every check found something)"}`,
     ];
     if (isSampleWall(state)) lines.unshift(SAMPLE_NOTE);
     return ok(lines.join("\n"), { ...reading, sample: isSampleWall(state) });
@@ -1301,8 +1319,10 @@ server.registerTool(
     trail.push({ before: state, after: canon(final), what: `move_scene "${card.headline}"` });
     undone.length = 0;
     const order = readingOrder(final.notes);
+    const group = final.groups.find((item) => item.noteIds.includes(card.id));
+    const groupLine = group ? ` It is still in "${group.title || "an untitled group"}"; a frame does not follow a move, so say if the act or sequence should change.` : "";
     return ok(
-      `Moved "${card.headline}" to ${args.after ? "after" : "before"} "${target.headline}": ${removed} arrow(s) removed, ${drawn} drawn, the wall tidied along them${where(live)}. Story order now: ${order.map((note, index) => `${index + 1}. ${note.headline}`).join(", ")}. One undo takes the whole move back.`,
+      `Moved "${card.headline}" to ${args.after ? "after" : "before"} "${target.headline}": ${removed} follows arrow(s) removed, ${drawn} drawn, setup arrows untouched, the wall tidied along them${where(live)}. Story order now: ${order.map((note, index) => `${index + 1}. ${note.headline}`).join(", ")}.${groupLine} One undo takes the whole move back.`,
       { order: order.map((note) => note.id) },
     );
   },
@@ -1390,10 +1410,9 @@ server.registerTool(
     const { project } = await readProject();
     const own = project.structures ?? [];
     const lines = [
-      `built in: ${TEMPLATES.length}`,
-      ...TEMPLATES.map((template) => `  - ${template.id} — "${template.name}" (${template.beats.length} beats)`),
       `the writer's own: ${own.length}`,
-      ...own.map((structure) => `  - ${structure.id} — "${structure.name}" (${structure.beats.length} beats: ${structure.beats.map((beat) => beat.name).join(", ")})`),
+      ...own.map((structure) => `  - ${structure.id} — "${structure.name}" (${structure.beats.length} beats: ${structure.beats.map((beat) => `${beat.name} at ${Math.round(beat.at * 100)}%`).join(", ")})`),
+      `built in: ${TEMPLATES.length} — ${TEMPLATES.map((template) => `${template.id} "${template.name}" (${template.beats.length} beats)`).join(", ")}; each beat's name, prompt and place in the story are in the JSON`,
     ];
     return ok(lines.join("\n"), { builtIn: TEMPLATES.map((template) => ({ id: template.id, name: template.name, beats: template.beats })), own });
   },
@@ -1415,7 +1434,7 @@ server.registerTool(
     const { project, boards, rev, base, live } = await readProject();
     const { project: next, structure } = addStructure(project, args.name, beats);
     await writeProject(next, boards, rev, base);
-    return ok(`Saved "${structure.name}" with ${beats.length} beats${where(live)}: ${beats.map((beat) => beat.name).join(", ")}.`, structure);
+    return ok(`Saved "${structure.name}" with ${beats.length} beats${where(live)}: ${beats.map((beat) => `${beat.name} at ${Math.round(beat.at * 100)}%`).join(", ")}. Each beat's prompt is its change line here; apply_template lays the same turns on another board, the next episode's, as beat cards to fill.`, structure);
   },
 );
 
@@ -1467,7 +1486,7 @@ server.registerTool(
   {
     title: "Write a scene",
     description:
-      "Write a card's scene text in Fountain — action, character cues in capitals, dialogue under them — onto the card by id. The card is then measured (its lines against a page) instead of estimated. An empty string clears it. Read read_pages first so the scene fits what is around it, and do not write scenes the writer has not asked for.",
+      "Write a card's scene text in Fountain — action, character cues in capitals, dialogue under them — onto the card by id; the scene heading comes from the card's place, so start with the action. The card is then measured (its lines as they print against a 55-line page) instead of estimated. An empty string clears it. Read read_pages first so the scene fits what is around it, and do not write scenes the writer has not asked for.",
     inputSchema: { id: z.string(), text: z.string() },
   },
   async (args) => {
@@ -1476,10 +1495,10 @@ server.registerTool(
       if (!result) return ok(`No card with id ${args.id}. Call list_board.`);
       return ok(`Nothing changed: "${result.headline}" already reads that way.`);
     }
-    const lines = args.text.split("\n").filter((line) => line.trim()).length;
+    const printed = sceneLineCount(args.text);
     return ok(
-      `Wrote "${result.headline}": ${lines} line(s), measured at ${formatPages(noteEighths(result))} of a page (a page is 55 lines of Courier 12; a fraction is rounded up to an eighth)${where(live)}. While the text stands the card is measured, not estimated; its estimate is untouched underneath.`,
-      result,
+      `Wrote "${result.headline}": ${printed} line(s) as they print (headings, blank lines and wrapped dialogue counted), measured at ${formatPages(noteEighths(result))} of a 55-line page, rounded to the nearest eighth and never below one${where(live)}. The heading comes from the card's place, so the text starts with the action. While the text stands the card is measured, not estimated; every reading uses the measure (eighths here), and the estimate underneath (lengthEighths) is untouched.`,
+      { ...result, eighths: noteEighths(result), measured: true, printedLines: printed },
     );
   },
 );
@@ -1499,13 +1518,16 @@ server.registerTool(
     const text = toFountain(state, { title: board?.name, premise: project.premise || undefined });
     const parsed = fromFountain(text);
     const ids = mergeFountain(state, parsed).matched.map((item) => item.id);
+    const pageNumbers = state.lock ? sceneNumbers(readingOrder(state.notes), state.lock) : null;
     const lines = [];
     let index = 0;
     for (const line of text.split("\n")) {
       if (/^\.(?!\.)/.test(line) && index < ids.length) {
         const note = state.notes.find((item) => item.id === ids[index]);
         index += 1;
-        lines.push(`${line}    [[id: ${note?.id ?? "?"} · ${note && isMeasured(note) ? "measured" : "estimated"} ${formatPages(note ? noteEighths(note) : 0)}pp]]`);
+        const standIn = note && !(note.location ?? "").trim() ? " · no place: the headline stands in for the heading" : "";
+        const numbered = note && pageNumbers?.get(note.id) ? ` · locked no. ${pageNumbers.get(note.id)}` : "";
+        lines.push(`${line}    [[id: ${note?.id ?? "?"} · ${note && isMeasured(note) ? "measured" : "estimated"} ${formatPages(note ? noteEighths(note) : 0)}pp${standIn}${numbered}]]`);
       } else {
         lines.push(line);
       }
@@ -1583,7 +1605,7 @@ server.registerTool(
     const { state } = await readBoard();
     const { project } = await readProject();
     const board = project.boards.find((item) => item.id === project.activeBoardId);
-    const brief = segmentBrief(state, args.ids, { title: board?.name });
+    const brief = segmentBrief(state, args.ids, { title: board?.name, boards: project.boards });
     if (!brief) return ok(`No cards with ids ${args.ids.join(", ")}. Call list_board.`);
     return ok(brief);
   },
@@ -1662,7 +1684,7 @@ server.registerTool(
     const note = unwritten
       ? [`${unwritten} of ${order.length} scenes are unwritten and count as one line each here, so this is the script so far, not the runtime: the estimate from the cards is about ${formatPages(boardEighths(state))} pages, the number to use until the scenes are written.`]
       : [];
-    return ok([`pages: ${result.pageCount} of ${Math.round(state.targetEighths / 8)}`, ...note, ...lines].join("\n"), result.scenes);
+    return ok([`pages: ${result.pageCount} of ${Math.round(state.targetEighths / 8)}`, `scene numbers here are ${state.lock ? "the locked numbers" : "wall order (not locked)"}`, ...note, ...lines].join("\n"), result.scenes);
   },
 );
 
@@ -1687,8 +1709,10 @@ server.registerTool(
   "unlock_numbers",
   { title: "Unlock the scene numbers", description: "Numbers follow the wall's order again.", inputSchema: {} },
   async () => {
+    const { state: before } = await readBoard();
+
     const { changed, live } = await commit({ type: "unlock_numbers" });
-    return ok(changed ? `Unlocked${where(live)}.` : "The numbers were not locked.");
+    return ok(changed ? `Unlocked ${Object.keys(before.lock?.numbers ?? {}).length} scene number(s)${where(live)}; scenes number by wall order again.` : "The numbers were not locked.");
   },
 );
 
@@ -1698,11 +1722,13 @@ server.registerTool(
     title: "Start a revision",
     description:
       `Name a revision and give it one of the industry's colours (${REVISION_COLORS.join(", ")}). Every card is snapshotted; from then on a changed line prints in the colour with a star in the margin, and a changed card wears the colour on the wall.`,
-    inputSchema: { name: z.string().min(1), color: z.string().optional() },
+    inputSchema: { name: z.string().optional(), color: z.string().optional() },
   },
   async (args) => {
-    const { changed, result, live } = await commit({ type: "start_revision", name: args.name, color: args.color });
-    if (!changed) return ok("No revision started: give it a name.");
+    const revisionName = (args.name ?? "").trim() || (args.color ? `${args.color.charAt(0).toUpperCase()}${args.color.slice(1)}` : "");
+    if (!revisionName) return ok("No revision started: give it a name, or a colour to name it after.");
+    const { changed, result, live } = await commit({ type: "start_revision", name: revisionName, color: args.color });
+    if (!changed) return ok("No revision started: one is already in progress; end_revision first.");
     return ok(`Started the ${result.color} revision "${result.name}"${where(live)}.`, { name: result.name, color: result.color, since: result.since });
   },
 );
@@ -1711,8 +1737,10 @@ server.registerTool(
   "end_revision",
   { title: "End the revision", description: "The marks come off; the snapshot is dropped.", inputSchema: {} },
   async () => {
+    const { state: before } = await readBoard();
+
     const { changed, live } = await commit({ type: "end_revision" });
-    return ok(changed ? `Revision ended${where(live)}.` : "No revision in progress.");
+    return ok(changed ? `Revision "${before.revision?.name ?? ""}" (${before.revision?.color ?? ""}) ended${where(live)}: its marks come off and its snapshot is dropped.` : "No revision in progress.");
   },
 );
 
@@ -1730,7 +1758,7 @@ server.registerTool(
     const { state } = await readBoard();
     const { project } = await readProject();
     const board = project.boards.find((item) => item.id === project.activeBoardId);
-    const brief = segmentBrief(state, args.ids, { title: board?.name });
+    const brief = segmentBrief(state, args.ids, { title: board?.name, boards: project.boards });
     if (!brief) return ok(`No cards with ids ${args.ids.join(", ")}. Call list_board.`);
     const provider = env.PLOTCODER_VIDEO_PROVIDER;
     if (!provider) {
@@ -1889,10 +1917,11 @@ server.registerTool(
     undone.push(last);
     const { boardId } = await readBoard();
     const live = await writeBoard(last.before, rev, base, boardId);
-    return ok(
-      `Undid ${last.what}${where(live)}. ${trail.length} more of mine can be undone.`,
-      last.before,
-    );
+    const orderLine = /^(move_scene|organize)/.test(last.what) ? ` Story order now: ${readingOrder(last.before.notes).map((note, index) => `${index + 1}. ${note.headline}`).join(", ")}.` : "";
+    const cardsDiff = last.before.notes.length - state.notes.length;
+    const countLine = cardsDiff > 0 ? ` ${cardsDiff} card(s) back.` : cardsDiff < 0 ? ` ${-cardsDiff} card(s) gone.` : "";
+    const more = trail.length >= TRAIL_CAP ? `${trail.length} more of mine can be undone — the most I keep, so the oldest have gone` : `${trail.length} more of mine can be undone`;
+    return ok(`Undid ${last.what}${where(live)}.${orderLine}${countLine} ${more}. list_board has the board.`, { undid: last.what, notes: last.before.notes.length, arrows: last.before.arrows.length, groups: last.before.groups.length });
   },
 );
 
@@ -1915,7 +1944,7 @@ server.registerTool(
     const after = normalizeState(JSON.parse(last.after));
     const live = await writeBoard(after, rev, base, boardId);
     trail.push(last);
-    return ok(`Redid ${last.what}${where(live)}. ${undone.length} more can be redone.`, after);
+    return ok(`Redid ${last.what}${where(live)}. ${undone.length} more can be redone. list_board has the board.`, { redid: last.what, notes: after.notes.length, arrows: after.arrows.length, groups: after.groups.length });
   },
 );
 
@@ -1924,23 +1953,52 @@ server.registerTool(
   {
     title: "Fold the corner",
     description:
-      `Fold the corner of cards — mark them as planting something — or unfold them. ${wordSentence("corner")} The setup arrow is create_arrow with kind 'setup'. Folding never moves a card.`,
+      `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 the wall stops asking where it comes back, listing the card under the reading's 'later' instead of 'payoffs'; later '' forgets it. Folding never moves a card.`,
     inputSchema: {
       ids: z.array(z.string()).min(1),
       plants: z.boolean(),
+      later: z.string().optional(),
     },
   },
   async (args) => {
-    const { result, live } = await commit({
+    let { result, live, changed } = await commit({
       type: "set_plant",
       ids: args.ids,
       plants: args.plants,
     });
+    let laterLine = "";
+    if (args.plants && args.later !== undefined) {
+      // A series plant (R50): the fold pays off on another board of the project.
+      // The kernel cannot check the board exists; this door can.
+      const { project } = await readProject();
+      const { state: now, boardId: current } = await readBoard();
+      const here = now.notes.filter((note) => args.ids.includes(note.id));
+      if (args.later.trim() === "") {
+        const cleared = await commit({ type: "set_payoff_board", ids: args.ids, boardId: null });
+        if (cleared.changed) {
+          result = cleared.result;
+          live = cleared.live;
+          changed = true;
+          laterLine = " The board it paid off on is forgotten; read_wall asks again until a setup arrow or a board pays it off.";
+        }
+      } else {
+        const target = findBoard(project, args.later);
+        if (!target) return ok(`No board called "${args.later}" yet. A fold pays off later on a board of the project: new_board "${args.later}" makes it (empty), open_board back to this one, then set_plant again with later.`);
+        if (target.id === (current ?? project.activeBoardId)) return ok(`"${target.name}" is this board. A payoff on the same board is a setup arrow: create_arrow from the fold to the scene, kind 'setup'.`);
+        const named = await commit({ type: "set_payoff_board", ids: args.ids, boardId: target.id });
+        if (named.changed) {
+          result = named.result;
+          live = named.live;
+          changed = true;
+        }
+        laterLine = ` ${here.length} card(s) pay off later, on "${target.name}": read_wall stops asking where they come back, and the card says so.`;
+      }
+    }
     const count = result?.length ?? 0;
-    if (count === 0) return ok("No change: those cards were already that way, or the ids are not on the board.");
+    if (!changed || count === 0) return ok("No change: those cards were already that way, or the ids are not on the board.");
     return ok(
       args.plants
-        ? `${count} card(s) now plant something${where(live)}. read_wall will ask about each until a setup arrow pays it off.`
+        ? `${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)}.`,
       result,
     );
@@ -1977,6 +2035,7 @@ server.registerTool(
     inputSchema: { id: z.string(), name: z.string().min(1) },
   },
   async (args) => {
+    const { state: before } = await readBoard();
     const { state, changed, result, live } = await commit({
       type: "rename_character",
       id: args.id,
@@ -1989,7 +2048,10 @@ server.registerTool(
         : ok(`No character with id ${args.id}. Call list_board for the cast.`);
     }
     const followed = state.notes.filter((note) => note.characterIds.includes(result.id)).length;
-    return ok(`Renamed to "${result.name}" (${result.id})${where(live)}; the name changed on ${followed} card${followed === 1 ? "" : "s"}.`, result);
+    const oldName = (before.characters.find((item) => item.id === result.id)?.name ?? "").trim();
+    const stale = oldName ? CHARACTER_FIELDS.filter((field) => (result[field] ?? "").toLowerCase().includes(oldName.toLowerCase())) : [];
+    const staleLine = stale.length ? ` The page's ${stale.join(", ")} still mention${stale.length === 1 ? "s" : ""} "${oldName}"; the page is untouched.` : "";
+    return ok(`Renamed to "${result.name}" (${result.id})${where(live)}; the name changed on ${followed} card${followed === 1 ? "" : "s"}.${staleLine}`, result);
   },
 );
 
@@ -2238,6 +2300,7 @@ server.registerTool(
     inputSchema: { from: z.string(), to: z.string(), kind: arrowKindSchema.optional() },
   },
   async (args) => {
+    const { boardId } = await readBoard();
     const { state, changed, result, live } = await commit({
       type: "create_arrow",
       from: args.from,
@@ -2248,13 +2311,19 @@ server.registerTool(
       // Say which of the three reasons it was. "Something went wrong" makes an
       // agent retry the same call; naming the cause makes it fix the input.
       const onBoard = (id) => state.notes.some((note) => note.id === id);
+      const { project: wholeProject, boards: allBoards } = await readProject();
+      const elsewhere = (id) => wholeProject.boards.find((meta) => meta.id !== (boardId ?? wholeProject.activeBoardId) && isBoardState(allBoards[meta.id]) && allBoards[meta.id].notes.some((note) => note.id === id));
+      const missing = (id) => {
+        const other = elsewhere(id);
+        return other ? `card ${id} is on another board, "${other.name}" — an arrow stays on one board; a fold that pays off there is set_plant with later: "${other.name}"` : `there is no card with id ${id}`;
+      };
       const why =
         args.from === args.to
           ? "a card cannot point at itself"
           : !onBoard(args.from)
-            ? `there is no card with id ${args.from}`
+            ? missing(args.from)
             : !onBoard(args.to)
-              ? `there is no card with id ${args.to}`
+              ? missing(args.to)
               : "that arrow already exists";
       return ok(`No arrow drawn: ${why}. Call list_board to check.`);
     }
@@ -2297,7 +2366,7 @@ server.registerTool(
 
 // --- The project ------------------------------------------------------
 
-function describeBoards(project, boards) {
+function describeBoards(project, boards, changedAt = null) {
   return project.boards
     .map((board, index) => {
       const state = boards[board.id];
@@ -2306,7 +2375,8 @@ function describeBoards(project, boards) {
         state && isBoardState(state)
           ? `${state.notes.length} cards, about ${formatPages(boardEighths(normalizeState(state)))} of ${formatPages(normalizeState(state).targetEighths)} pages`
           : "no cards";
-      return `  ${index + 1}. ${board.id} — "${board.name}"${open}: ${shape}`;
+      const changed = changedAt?.[board.id] ? `, last changed ${changedAt[board.id]}` : "";
+      return `  ${index + 1}. ${board.id} — "${board.name}"${open}: ${shape}${changed}`;
     })
     .join("\n");
 }
@@ -2320,13 +2390,13 @@ server.registerTool(
     inputSchema: {},
   },
   async () => {
-    const { project, boards, live, base } = await readProject();
+    const { project, boards, live, base, changedAt } = await readProject();
     return ok(
       [
         `Project "${project.name}" (${door(live, base)})`,
         `premise: ${project.premise ? `"${project.premise}"` : "(not set)"}`,
         `boards: ${project.boards.length}`,
-        describeBoards(project, boards),
+        describeBoards(project, boards, changedAt),
       ].join("\n"),
       project,
     );
@@ -2401,8 +2471,8 @@ server.registerTool(
     const own = list.filter((item) => !item.builtIn).length;
     return ok(
       [
-        `reminders on "${project.name}" (${door(live, base)}): ${list.length} — ${list.length - own} the house principles the app starts with (built in), ${own} the writer's own${own === 0 ? "; add_reminder adds one the writer asks to keep" : ""}`,
-        ...list.map((item) => `  - ${item.id}${item.builtIn ? " (built in)" : ""} — ${item.title}: ${item.body}`),
+        `reminders on "${project.name}" (${door(live, base)}): ${list.length} — ${list.length - own} the house principles the app starts with (built in), ${own} the writer's own${own === 0 ? "; add_reminder adds one the writer asks to keep" : ""}. Reminders live on the project and go with it`,
+        ...list.map((item) => `  - ${item.id}${item.builtIn ? " (built in)" : ""} — ${item.body.replace(/\.$/, "").startsWith(item.title.replace(/\.$/, "")) ? item.body : `${item.title}: ${item.body}`}`),
       ].join("\n"),
       list,
     );
@@ -2541,12 +2611,13 @@ 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), pages: pagesSchema.optional(), minutes: z.number().positive().optional() },
+    inputSchema: { name: z.string().min(1), board: 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.");
-    const record = renameProject(emptyProject(), args.name.trim());
+    let record = renameProject(emptyProject(), args.name.trim());
+    if (args.board?.trim()) record = renameBoard(record, record.activeBoardId, args.board.trim());
     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;
@@ -2602,7 +2673,7 @@ server.registerTool(
     for (const row of owned) plans.push(await deletionPlan(row));
     const survive = shared.length ? ` ${shared.length} project(s) shared with the writer by others stay: ${shared.map((row) => `"${row.record.name}"`).join(", ")}.` : "";
     if (plans.length === 0) return ok(`The account holds nothing of the writer's own to delete.${survive}`);
-    if (!args.confirm) return ok(`Emptying the account deletes ${plans.length} project(s) of the writer's own: ${plans.map(describePlan).join("; ")}. Cannot be undone. Ask the writer; export_project each first if they might want them back; then pass confirm: true.${survive}`, plans);
+    if (!args.confirm) return ok(`Emptying the account deletes ${plans.length} project(s) of the writer's own: ${plans.map(describePlan).join("; ")}. Cannot be undone. Ask the writer, or if they have already said so, pass confirm: true now; export_project each first if they might want them back.${survive}`, plans);
     for (const plan of plans) await deleteProjectRows(plan);
     const next = await workWhatIsLeft(plans.map((plan) => plan.id));
     return ok(`Emptied the account as ${account.email}: deleted ${plans.map(describePlan).join("; ")}.${survive}${next}`, plans);
@@ -2665,7 +2736,9 @@ server.registerTool(
     const { project, boards, reminders } = await readProject();
     const file = toProjectFile({ project, boards, reminders: reminders ?? null });
     const cards = countCards(boards);
-    const what = `"${project.name}": ${project.boards.length} board(s), ${cards} card(s)${reminders?.length ? `, ${reminders.length} reminder(s)` : ""}${project.structures?.length ? `, ${project.structures.length} structure(s)` : ""}. Pictures and takes on the account are not in the file`;
+    const ownReminders = (reminders ?? []).filter((item) => !item.builtIn).length;
+    const builtInReminders = (reminders ?? []).length - ownReminders;
+    const what = `"${project.name}": ${project.boards.length} board(s) — ${project.boards.map((meta) => `"${meta.name}" (${isBoardState(boards[meta.id]) ? boards[meta.id].notes.length : 0} cards)`).join(", ")} — ${cards} card(s) in all${reminders?.length ? `, ${reminders.length} reminder(s) (${builtInReminders} built in, ${ownReminders} the writer's own)` : ", the six built-in reminders come with every project and no reminders of the writer's own (none to write)"}${project.structures?.length ? `, ${project.structures.length} structure(s)` : ", no structures of the writer's own (none to write)"}. Pictures and takes on the account are not in the file`;
     if (args.path) {
       fs.mkdirSync(path.dirname(path.resolve(args.path)), { recursive: true });
       fs.writeFileSync(args.path, JSON.stringify(file, null, 2));
@@ -2765,7 +2838,7 @@ server.registerTool(
     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)}. It is empty. 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}) 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}" comes back. It is empty. 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,
     );
   },

package/src/board/agents.js

@@ -42,12 +42,12 @@ export const AGENTS = {
       text: "Skip this when the account is the wall. Without an account, a wall is a folder: any folder, empty is fine — choose one that will outlive your session, never a scratch one. The app run from that folder shows the wall, and the server writes it there (PLOTCODER_ROOT, or the folder it is run from). A fresh folder holds the sample; new_board for the writer's wall, then rename_project. No app running? export_fountain is the wall in order, as text.",
     },
   ],
-  firstNote: "These four are about the wall you will work, so after open_project, open_board, new_project or empty_account, read_wall again. On an account with no project yet, read_wall has nothing to read and says so, and list_reminders gives the house principles every project starts with; new_project, then the four again. No server in front of you, and no shell to take the shell door? Nothing gets you in from inside the session: say so, and ask the person to wire the server and start a new session.",
+  firstNote: "Make these four before anything else; none depends on another, so any order is fine. They are about the wall you will work, so after open_project, open_board, new_project or empty_account, read_wall again. On an account with no project yet, read_wall has nothing to read and says so, and list_reminders gives the house principles every project starts with; new_project, then the four again. No server in front of you, and no shell to take the shell door? Nothing gets you in from inside the session: say so, and ask the person to wire the server and start a new session.",
   first: [
     { tool: "list_words", why: "the room's words, the app's meaning." },
-    { tool: "read_wall", why: "what is here, and what it asks. A fresh folder holds a sample wall (Maya, Tom, the letter) and says so; it is not the writer's." },
+    { tool: "read_wall", why: "the reading: the beats, the runs, the setups, and what the wall asks. The records — every card, the cast, the places — are list_board's. A fresh folder holds a sample wall (Maya, Tom, the letter) and says so; it is not the writer's." },
     { tool: "list_workflows", why: "what a writer can ask you for." },
-    { tool: "list_reminders", why: "the house principles the app starts with, and the writer's own; read them before you change anything." },
+    { tool: "list_reminders", why: "the house principles the app starts with, and the writer's own; read them before you change anything. Reminders live on the project and go with it." },
   ],
   rules: [
     "Questions, not fixes, until the writer says.",
@@ -64,7 +64,7 @@ export const AGENTS = {
 
 /** The on-ramp as one text: the file at /llms.txt, and what an agent reads. */
 export function agentsAsText() {
-  const lines = ["# PlotCoder — for agents", "", AGENTS.lead, "", `The guide, read once before anything: ${AGENTS.guide}. The guide is the whole and this page is its first page; where the two differ, the guide wins.`, "", "## Doors"];
+  const lines = ["# PlotCoder — for agents", "", AGENTS.lead, "", `The guide: ${AGENTS.guide}. Read it once, before your first call if you can; it is the whole and this page is its first page, and where the two differ, the guide wins. Then Call these first, below. The doors between are for wiring a server in; skip them when the tools are already in front of you.`, "", "## Doors"];
   for (const door of AGENTS.doors) {
     lines.push(`- ${door.name}: ${door.text}`);
     if (door.code) lines.push("", "```", door.code, "```", "");

package/src/board/readWall.d.ts

@@ -61,6 +61,8 @@ export type WallReading = {
   /** Every planted card: the scene that pays it off (first setup arrow, by wall order), or null while unpaid. */
   /** For each folded card, the cards its setup arrows land on, in wall order; empty when unpaid. */
   payoffs: Record<string, string[]>;
+  /** Folded cards that pay off on another board of the project (R50): the card and the board. */
+  later: { id: string; boardId: string }[];
   findings: Finding[];
 };
 

package/src/board/readWall.js

@@ -304,11 +304,17 @@ export function readWall(state) {
       .map((arrow) => arrow.to)
       .sort((a, b) => (wallIndex.get(a) ?? Infinity) - (wallIndex.get(b) ?? Infinity));
     // Every payoff, in wall order: a card can plant two things (the ledger
-    // pays off at the cash and again at the initials), and both count.
+    // pays off at the cash and again at the initials), and both count. A
+    // fold that pays off only on another board is not here at all — it is
+    // under `later` — so the two never disagree about one card.
+    if (!heads.length && note.payoffBoardId) continue;
     payoffs[note.id] = heads;
   }
+  // A fold that pays off on another board (R50) is not unpaid: it is listed
+  // under `later`, and the door that knows the project names the board.
+  const later = order.filter((note) => note.plants && note.payoffBoardId).map((note) => ({ id: note.id, boardId: note.payoffBoardId }));
   for (const note of order) {
-    if (note.plants && !paysOff.has(note.id)) {
+    if (note.plants && !paysOff.has(note.id) && !note.payoffBoardId) {
       findings.push({
         kind: "unpaid",
         ids: [note.id],
@@ -372,6 +378,7 @@ export function readWall(state) {
     runs,
     setups,
     payoffs,
+    later,
     findings,
   };
 }

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;
+  /** When folded: the id of another board of the project where it pays off (R50), or null. */
+  payoffBoardId: string | null;
   /** Where the scene happens (R37): a phrase in the writer's words; empty until set. */
   location: string;
   /** The scene's text in Fountain (R23 b): action, cues, dialogue; empty until written. */
@@ -161,6 +163,7 @@ export type Command =
   | ({ 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_payoff_board"; ids: string[]; boardId: string | null }
   | { type: "set_location"; ids: string[]; location: string }
   | { type: "apply_template"; template: string; beats?: Array<{ name: string; prompt: string; at: number }> }
   | { type: "set_text"; id: string; text: string }

package/src/board/reducer.js

@@ -233,6 +233,9 @@ export function seedState(now = nowIso()) {
     location: "",
     text: "",
     plants: false,
+    // A fold that pays off on another board — a later episode — names it here;
+    // null claims nothing (R50).
+    payoffBoardId: null,
     createdAt: now,
     updatedAt: now,
   });
@@ -325,6 +328,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 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 R37 have no place; a scene is nowhere until it is.
     const location = typeof note?.location === "string" ? note.location : "";
     // Cards written before pages (R23 b) have no text; a scene is unwritten until it is.
@@ -336,13 +341,14 @@ export function normalizeState(value) {
       Array.isArray(note.characterIds) &&
       sameIds(note.characterIds, characterIds) &&
       note.plants === plants &&
+      note.payoffBoardId === payoffBoardId &&
       note.location === location &&
       note.text === text
     ) {
       return note;
     }
     patched = true;
-    return { ...note, rank, lengthEighths, characterIds, plants, location, text };
+    return { ...note, rank, lengthEighths, characterIds, plants, payoffBoardId, location, text };
   });
 
   // Boards written before the production half (Roadmap 2, item 8) have no
@@ -416,6 +422,7 @@ export function applyCommand(state, command, now = nowIso()) {
             : clampEighths(command.lengthEighths, DEFAULT_NOTE_EIGHTHS, MAX_NOTE_EIGHTHS),
         characterIds: knownCast(command.characterIds, state.characters ?? []),
         plants: command.plants === true,
+        payoffBoardId: null,
         location: cleanPlace(command.location),
         text: typeof command.text === "string" ? command.text : "",
         z: maxZ(state.notes) + 1,
@@ -802,7 +809,8 @@ export function applyCommand(state, command, now = nowIso()) {
         id: newId(),
         headline: item.name,
         change: item.prompt,
-        color: NOTE_COLORS[(state.notes.length + index) % NOTE_COLORS.length],
+        // One colour: paper means nothing to the app, and a structure is not a pattern (round eleven).
+        color: "yellow",
         x: left + (index % 5) * (NOTE_WIDTH + 28),
         y: top + Math.floor(index / 5) * (NOTE_HEIGHT + 40),
         rotate: ((index % 5) - 2) * 0.8,
@@ -811,6 +819,7 @@ export function applyCommand(state, command, now = nowIso()) {
         lengthEighths: null,
         characterIds: [],
         plants: false,
+        payoffBoardId: null,
         location: "",
         text: "",
         createdAt: now,
@@ -895,8 +904,30 @@ export function applyCommand(state, command, now = nowIso()) {
       const plants = command.plants === true;
       const touched = [];
       const notes = state.notes.map((note) => {
-        if (!ids.has(note.id) || note.plants === plants) return note;
-        const next = bump(note, { plants }, now);
+        if (!ids.has(note.id)) return note;
+        // Unfolding forgets where it paid off; a claim that no longer stands.
+        const payoffBoardId = plants ? note.payoffBoardId : null;
+        if (note.plants === plants && note.payoffBoardId === payoffBoardId) return note;
+        const next = bump(note, { plants, payoffBoardId }, now);
+        touched.push(next);
+        return next;
+      });
+      if (touched.length === 0) return { state, changed: false };
+      return { state: { ...state, notes }, changed: true, result: touched };
+    }
+
+    // A fold that pays off on another board of the project (R50): the wall
+    // stops asking where it comes back, and the reading says where. The
+    // kernel cannot check the board exists; the door that knows the project
+    // does. Null takes the claim back.
+    case "set_payoff_board": {
+      const ids = new Set(command.ids);
+      if (ids.size === 0) return { state, changed: false };
+      const payoffBoardId = typeof command.boardId === "string" && command.boardId ? command.boardId : null;
+      const touched = [];
+      const notes = state.notes.map((note) => {
+        if (!ids.has(note.id) || !note.plants || note.payoffBoardId === payoffBoardId) return note;
+        const next = bump(note, { payoffBoardId }, now);
         touched.push(next);
         return next;
       });

package/src/board/workflows.d.ts

@@ -22,5 +22,5 @@ export declare function workflowById(id: string): Workflow | null;
 export declare function segmentBrief(
   state: BoardState,
   ids: string[],
-  options?: { title?: string },
+  options?: { title?: string; boards?: { id: string; name: string }[] },
 ): string | null;

package/src/board/workflows.js

@@ -30,7 +30,7 @@ export const WORKFLOWS = [
       { 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 in the headline for now.", tool: "the headline" },
       { 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: "Say \"later in the series\" when it pays off outside this episode, so the fold is deliberate.", tool: "set_plant, create_arrow" },
+      { question: "What is planted, and where does it pay off?", hint: "Name the episode when it pays off outside this one, so the fold is deliberate and the wall knows where to look.", tool: "set_plant with later, create_arrow" },
       { question: "Which scenes do you already know run long or short?", hint: "A day in the story is not a page count; leave the rest unsized.", tool: "set_length" },
       { question: "What are the project and the board called?", hint: "The series, and this episode.", tool: "rename_project, rename_board" },
       { question: "What must not be invented?", hint: "Looks and voices are yours until you say; so is anything the treatment does not state.", tool: "update_character, later" },
@@ -91,6 +91,7 @@ function personLine(character) {
   if (character.voice) lines.push(`voice: ${character.voice}`);
   if (character.wants) lines.push(`wants: ${character.wants}`);
   if (character.needs) lines.push(`needs: ${character.needs}`);
+  if (character.notes) lines.push(`notes: ${character.notes}`);
   return `${character.name}${lines.length ? ` — ${lines.join("; ")}` : " — (no page yet)"}`;
 }
 
@@ -120,7 +121,12 @@ export function segmentBrief(state, ids, options = {}) {
     lines.push("");
     lines.push(`SCENE: ${note.headline}${note.location ? ` — at ${note.location}` : ""}`);
     lines.push(`WHAT CHANGES: ${note.change}`);
-    if (note.plants) lines.push("PLANTS: something here pays off later; keep it visible.");
+    if (note.plants) {
+      const heads = state.arrows.filter((arrow) => arrow.kind === "setup" && arrow.from === note.id).map((arrow) => byId.get(arrow.to)?.headline).filter(Boolean);
+      const later = note.payoffBoardId ? (options.boards ?? []).find((board) => board.id === note.payoffBoardId)?.name ?? "a later board" : null;
+      const where = heads.length ? `pays off at ${heads.map((headline) => `"${headline}"`).join(" and ")}` : later ? `pays off later, on "${later}"` : "pays off later, nowhere yet";
+      lines.push(`PLANTS: something here ${where}; keep it visible.`);
+    }
     if (note.text && note.text.trim()) {
       lines.push("SCRIPT:");
       lines.push(note.text.trim());
@@ -129,6 +135,6 @@ export function segmentBrief(state, ids, options = {}) {
     }
   }
   lines.push("");
-  lines.push(`AFTER: ${notes.at(-1).change}`);
+  lines.push(`AFTER: ${notes.at(-1).change}${notes.length === 1 ? " (the change line, until the scene is written)" : ""}`);
   return lines.join("\n");
 }