plotcoder-board 0.1.14 → 0.1.16

package/README.md

@@ -41,7 +41,7 @@ Every board verb goes through one command kernel, `src/board/reducer.js`, and th
 
 - **The wall.** Tap the words to type, drag the paper to move. Lasso to select, then Group. Drag a card's handle onto another card for an arrow. ⌘Z takes back any change, whichever door made it.
 - **`window.plotcoder`** on the page, for a console or a CDP session.
-- **The MCP server**, published to npm as `plotcoder-board`: `npx -y plotcoder-board@latest` is the server, `npx -y plotcoder-board@latest call <tool> '{json}'` one call from a shell, `npx -y plotcoder-board@latest serve` the hosted door on a port (a `Dockerfile` is here too). Inside the repo it is `scripts/plotcoder-mcp.mjs`, wired for Cursor in `.cursor/mcp.json` and for Claude Code in `.mcp.json` (run `npm ci` once first). A version tag (`v0.2.0`) publishes it, with `NPM_TOKEN` in the repo's secrets. Seventy-two tools: reading (`list_board`, `read_wall`, `read_pages`, `read_character`, `page_count`, `list_words`, `list_workflows`, `segment_brief`); the card, cast, place, group and arrow verbs, `set_logline`, `set_target`, `set_rank`, `set_plant`, `write_scene`, `move_scene`, `organize`, `apply_template` with `list_structures`, `save_structure`, `remove_structure`; `undo` and `redo`; the project's `list_boards`, `open_board`, `new_board`, `rename_board`, `delete_board`, `set_premise`, `rename_project` and the reminders; Fountain and Final Draft both ways; the production half (`lock_numbers`, `unlock_numbers`, `start_revision`, `end_revision`); the project as a file both ways (`export_project`, `import_project`); and, through the account door, `list_projects`, `open_project`, `new_project`, `delete_project`, `empty_account`, `delete_account`, `add_picture`, `add_take`, `list_takes`, `list_files`, `remove_file`, `build_segment`. If the dev app is open, a tool call lands on the wall within a second; if not, it edits the board file and the wall catches up on the next load.
+- **The MCP server**, published to npm as `plotcoder-board`: `npx -y plotcoder-board@latest` is the server, `npx -y plotcoder-board@latest call <tool> '{json}'` one call from a shell, `npx -y plotcoder-board@latest serve` the hosted door on a port (a `Dockerfile` is here too). Inside the repo it is `scripts/plotcoder-mcp.mjs`, wired for Cursor in `.cursor/mcp.json` and for Claude Code in `.mcp.json` (run `npm ci` once first). A version tag (`v0.2.0`) publishes it, with `NPM_TOKEN` in the repo's secrets. Seventy-eight tools: reading (`list_board`, `read_wall`, `read_pages`, `read_character`, `page_count`, `list_words`, `list_workflows`, `segment_brief`, `compare_structure`); the card, cast, place, group (with `add_to_group`) and arrow verbs, `set_logline`, `set_target`, `set_rank`, `set_plant`, `write_scene`, `move_scene`, `organize`, `apply_template` with `list_structures`, `save_structure`, `remove_structure`; `leave_question` and `ask_again`; `undo` and `redo`; the project's `list_boards`, `open_board`, `new_board`, `rename_board`, `delete_board`, `set_premise`, `rename_project` and the reminders; Fountain and Final Draft both ways, Markdown and plain text out (`export_markdown`, `export_text`); the production half (`lock_numbers`, `unlock_numbers`, `start_revision`, `end_revision`); the project as a file both ways (`export_project`, `import_project`); and, through the account door, `list_projects`, `open_project`, `new_project`, `delete_project`, `empty_account`, `delete_account`, `add_picture`, `add_take`, `list_takes`, `list_files`, `remove_file`, `build_segment`. If the dev app is open, a tool call lands on the wall within a second; if not, it edits the board file and the wall catches up on the next load.
 - **The account door.** With `PLOTCODER_EMAIL` and `PLOTCODER_PASSWORD` in the agent's environment — the writer's own — and no dev app answering, the same server works the writer's project on the account directly, and every change lands live on every open wall. `PLOTCODER_PROJECT` picks a project by name or id. No account yet? `claim_account` makes one with the writer's email and a password they chose. The on-ramp — the doors, what to call first, the rules — is in the app behind *Are you an agent? Start here* and served at [plotcoder.com/llms.txt](https://plotcoder.com/llms.txt), both from `src/board/agents.js`.
 
 An agent should call the tools, never fake mouse drags. The skill in `.cursor/skills/plotcoder-board/SKILL.md` says how; `.claude/skills/plotcoder-board` is a symlink to the same file.
@@ -51,9 +51,9 @@ An agent should call the tools, never fake mouse drags. The skill in `.cursor/sk
 A **blind run** is a fresh agent given the on-ramp and a treatment and nothing
 else, asked to build a wall and to keep a log of everything that made the job
 harder than it should have been. The friction log is the product; the wall is
-just what produces it. Three rounds have been run and all 73 of their
-findings are fixed; the fourth ran through the account door and its twenty-three
-are fixed too. [`blind-runs/`](blind-runs/) holds the rules that keep a round honest,
+just what produces it. Thirteen rounds have been run, the first three through a
+repo checkout and the rest through the account door; every finding from the
+first twelve is fixed, and round thirteen's six chosen first are too. [`blind-runs/`](blind-runs/) holds the rules that keep a round honest,
 the table of rounds, and the next round's prompt with the test account filled in.
 
 A round works a **test account** — a throwaway marked on its writer row, and the
@@ -96,4 +96,4 @@ next round into a test of `claim_account` instead of the door it meant to test.
 
 ## Status
 
-Version 0.1.0. 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, and goes out and comes in as Fountain or Final Draft. 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.15. 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.14",
+  "version": "0.1.16",
   "type": "module",
   "scripts": {
     "dev": "vite",

package/scripts/plotcoder-mcp-server.mjs

@@ -41,6 +41,7 @@ import {
 import { TEMPLATES } from "../src/board/templates.js";
 import { wordSentence, wordsAsText } from "../src/board/words.js";
 import { fromFountain, mergeFountain, toFountain } from "../src/board/fountain.js";
+import { toMarkdown, toPlainText } from "../src/board/markdown.js";
 import { fromProjectFile, toProjectFile } from "../src/board/projectFile.js";
 import { describeSetAside, fromFdx, toFdx } from "../src/board/fdx.js";
 import { paginate } from "../src/board/paginate.js";
@@ -74,6 +75,7 @@ import {
   liftCast,
   mergeRoster,
   sameRoster,
+  scriptTitles,
   withRoster,
 } from "../src/board/project.js";
 
@@ -698,7 +700,18 @@ async function writeBoard(next, rev, base, boardId = null, roster = "merge") {
       const boards = {};
       for (const [id, state] of Object.entries(held.boards)) boards[id] = withRoster(state, project);
       boards[boardId ?? project.activeBoardId] = withRoster(toWrite, project);
+      // The order matters on the bridge: the board frame carries the exact roster
+      // and lands first, so the wall records one undo step holding the card, the
+      // cast and the person together (R33, R51); the project frame that follows
+      // then changes nothing. The account door keeps the project first, because
+      // its live path composes a board's cast against the project row it holds.
+      if (base === ACCOUNT) {
+        await writeProject(project, boards, held.rev, held.base);
+        return writeBoardRaw(toWrite, rev, base, boardId);
+      }
+      const live = await writeBoardRaw(toWrite, rev, base, boardId);
       await writeProject(project, boards, held.rev, held.base);
+      return live;
     }
   }
   return writeBoardRaw(toWrite, rev, base, boardId);
@@ -746,6 +759,9 @@ const TRAIL_CAP = 50;
 const trail = [];
 /** What undo took back, newest last; a new change of this server's clears it. */
 const undone = [];
+/** The last read_wall's questions, and what changed since: a leave answers the reading in front of the agent (round thirteen, entry 19). */
+let lastReading = null;
+const sinceRead = [];
 
 function describeCommand(command) {
   switch (command.type) {
@@ -787,11 +803,42 @@ async function commit(command) {
 
   const live = await writeBoard(next, rev, base, boardId, "exact");
   trail.push({ before: state, after: canon(next), what: describeCommand(command) });
+  sinceRead.push(describeCommand(command));
   if (trail.length > TRAIL_CAP) trail.shift();
   undone.length = 0;
   return { state: next, changed, result, live };
 }
 
+/**
+ * Several kernel commands as one change. Read once; `build(step, current)` applies
+ * each command through the kernel against the running state; write once. One tool
+ * call is then one frame on the bridge — one ⌘Z on the wall — and one entry on this
+ * server's own trail, however many commands it took: create_note with its cast,
+ * set_plant with later, move_scene, an import. Before this, ⌘Z on the wall took the
+ * cast off an agent's new card and left the card (R33).
+ */
+async function commitAll(what, build) {
+  const { state, rev, base, boardId } = await readBoard();
+  let current = state;
+  let changed = false;
+  const step = (command) => {
+    const out = applyCommand(current, command);
+    if (out.changed) {
+      current = out.state;
+      changed = true;
+    }
+    return out;
+  };
+  const value = await build(step, () => current);
+  if (!changed) return { state: current, changed: false, value, live: base !== null };
+  const live = await writeBoard(current, rev, base, boardId, "exact");
+  trail.push({ before: state, after: canon(current), what });
+  sinceRead.push(what);
+  if (trail.length > TRAIL_CAP) trail.shift();
+  undone.length = 0;
+  return { state: current, changed: true, value, live };
+}
+
 /** Said once per session: that cards stack until organize (round seven, finding 11). */
 /** Where a new card lands when the agent gives no position: after the last card in reading order, wrapping five wide, so cards never stack (round eleven, finding 14). */
 function nextPlace(state) {
@@ -1045,22 +1092,37 @@ server.registerTool(
   {
     title: "Set card length",
     description:
-      "Set how long cards run, in pages. An ordinary scene is about 1; a quick beat might be 0.25; a set piece might be 3 or 4. This is an estimate the writer owns — set it when you are told a length or when the card plainly describes one, and do not silently re-estimate a card someone has already sized.",
+      "Set how long cards run, in pages. An ordinary scene is about 1; a quick beat might be 0.25; a set piece might be 3 or 4. This is an estimate the writer owns — set it when you are told a length or when the card plainly describes one, and do not silently re-estimate a card someone has already sized. Pass pages \"unsized\" (or 0) to take a length away: the card claims nothing again and reads as about a page, the way a new card does.",
     inputSchema: {
       ids: z.array(z.string()).min(1),
-      pages: pagesSchema,
+      pages: z
+        .union([pagesSchema, z.literal(0), z.literal("unsized"), z.null()])
+        .describe('Pages; a fraction is fine. "unsized" (or 0) takes the length away.'),
     },
   },
   async (args) => {
-    const { state, result, live } = await commit({
+    const unsizing = args.pages === "unsized" || args.pages === 0 || args.pages === null;
+    const { state, changed, result, live } = await commit({
       type: "set_length",
       ids: args.ids,
-      lengthEighths: toEighths(args.pages),
+      lengthEighths: unsizing ? null : toEighths(args.pages),
     });
-    return ok(
-      `${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,
-    );
+    if (!changed) {
+      const these = args.ids.length === 1 ? "the card is" : "those cards are";
+      return ok(
+        unsizing
+          ? `Nothing to unsize: ${these} unsized already, or not on the board (list_board for the ids).`
+          : `Nothing changed: ${these} at ${args.pages} page(s) already, or not on the board (list_board for the ids).`,
+      );
+    }
+    const runtime = `The board runs about ${formatPages(boardEighths(state))} pages against a ${formatPages(state.targetEighths)}-page target.`;
+    if (unsizing) {
+      return ok(
+        `${result.length} card(s) unsized${where(live)}: no length claimed, so each reads as about a page until someone sizes it, and list_board says "unsized". ${runtime}`,
+        result,
+      );
+    }
+    return ok(`${result.length} card(s) now run ${args.pages} page(s), the writer's estimate${where(live)}. ${runtime}`, result);
   },
 );
 
@@ -1106,45 +1168,47 @@ server.registerTool(
   },
   async (args) => {
     const landing = args.x === undefined && args.y === undefined ? nextPlace((await readBoard()).state) : { x: args.x, y: args.y };
-    let { result, live } = await commit({
-      type: "create_note",
-      headline: args.headline,
-      change: args.change,
-      // One colour unless the agent chooses: a wall an agent builds in one go
-      // would otherwise stripe through the cycle, and a writer reads a pattern
-      // into it (round four, finding 17). The wall's own new-card button keeps
-      // cycling for a person adding cards by hand.
-      color: args.color ?? "yellow",
-      rank: args.rank,
-      lengthEighths: args.pages === undefined ? undefined : toEighths(args.pages),
-      plants: args.plants,
-      location: args.location,
-      x: landing.x,
-      y: landing.y,
-    });
-    let castLine = "";
-    if (args.characters && args.characters.length && result?.id) {
-      const added = [];
-      const ids = [];
-      for (const name of args.characters) {
-        const { state } = await readBoard();
-        const wanted = name.trim().toLowerCase();
-        let person = state.characters.find((item) => item.id === name) ?? state.characters.find((item) => item.name.trim().toLowerCase() === wanted);
-        if (!person) {
-          const made = await commit({ type: "add_character", name: name.trim() });
-          person = made.result;
-          if (person) added.push(`${person.name} (${person.id})`);
+    const names = (args.characters ?? []).map((name) => name.trim()).filter(Boolean);
+    const added = [];
+    // The card, anyone new in its cast, and the casting land as one change, so
+    // one ⌘Z on the wall takes back the whole call and not just the cast.
+    const { value: result, live } = await commitAll(`create_note "${args.headline}"`, (step, current) => {
+      let made = step({
+        type: "create_note",
+        headline: args.headline,
+        change: args.change,
+        // One colour unless the agent chooses: a wall an agent builds in one go
+        // would otherwise stripe through the cycle, and a writer reads a pattern
+        // into it (round four, finding 17). The wall's own new-card button keeps
+        // cycling for a person adding cards by hand.
+        color: args.color ?? "yellow",
+        rank: args.rank,
+        lengthEighths: args.pages === undefined ? undefined : toEighths(args.pages),
+        plants: args.plants,
+        location: args.location,
+        x: landing.x,
+        y: landing.y,
+      }).result;
+      if (names.length && made?.id) {
+        const ids = [];
+        for (const name of names) {
+          const wanted = name.toLowerCase();
+          let person = current().characters.find((item) => item.id === name) ?? current().characters.find((item) => item.name.trim().toLowerCase() === wanted);
+          if (!person) {
+            person = step({ type: "add_character", name }).result;
+            if (person) added.push(`${person.name} (${person.id})`);
+          }
+          if (person && !ids.includes(person.id)) ids.push(person.id);
+        }
+        if (ids.length) {
+          const cast = step({ type: "set_cast", ids: [made.id], characterIds: ids });
+          // The card as it is now, cast and all, so the reply's JSON agrees with its prose.
+          made = cast.state.notes.find((note) => note.id === made.id) ?? made;
         }
-        if (person) ids.push(person.id);
-      }
-      if (ids.length) {
-        const cast = await commit({ type: "set_cast", ids: [result.id], characterIds: ids });
-        // The card as it is now, cast and all, so the reply's JSON agrees with its prose.
-        const after = cast.state.notes.find((note) => note.id === result.id);
-        if (after) result = after;
       }
-      castLine = ` Cast: ${args.characters.map((name) => name.trim()).join(", ")}${added.length ? ` (added to the roster: ${added.join(", ")})` : ""}.`;
-    }
+      return made;
+    });
+    const castLine = names.length && result?.id ? ` Cast: ${names.join(", ")}${added.length ? ` (added to the roster: ${added.join(", ")})` : ""}.` : "";
     const landed = [
       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"}`,
@@ -1222,13 +1286,20 @@ server.registerTool(
   {
     title: "Delete note",
     description:
-      "Remove a card from the board. Also removes any arrows touching it and drops it from groups.",
+      "Remove a card from the board. Its arrows go with it and it leaves its group; the reply names each arrow by its cards and says what the group kept, and undo brings all of it back.",
     inputSchema: { id: z.string() },
   },
   async (args) => {
-    const { result } = await commit({ type: "delete_note", id: args.id });
+    const { result, live } = await commit({ type: "delete_note", id: args.id });
     if (result === undefined) return ok(`No card with id ${args.id}.`);
-    return ok("Deleted card.", result);
+    // Say what went with the card (round thirteen, entry 17).
+    const arrows = result.arrows.length
+      ? ` Took ${result.arrows.length === 1 ? "its arrow" : `its ${result.arrows.length} arrows`} with it: ${result.arrows.map((arrow) => `"${arrow.fromHeadline}" → "${arrow.toHeadline}" (${arrow.kind})`).join(", ")}.`
+      : " No arrow touched it.";
+    const groups = result.groups
+      .map((group) => (group.dissolved ? ` Its group "${group.title}" dissolved: a frame needs two cards.` : ` Left its group "${group.title}", which keeps ${group.remaining} card${group.remaining === 1 ? "" : "s"}.`))
+      .join("");
+    return ok(`Deleted "${result.headline}"${where(live)}.${arrows}${groups}`, result);
   },
 );
 
@@ -1249,6 +1320,8 @@ server.registerTool(
     const { boards: boardsForRead } = await readProject();
     const elsewhereForRead = castElsewhere(projectForRead, boardsForRead, readBoardId ?? projectForRead.activeBoardId);
     const reading = readWall(state, { elsewhere: Object.keys(elsewhereForRead) });
+    lastReading = { findings: reading.findings };
+    sinceRead.length = 0;
     const runs = describeRuns(reading, state).map((line, index) => {
       const ids = reading.runs[index]?.ids ?? [];
       return ids.length ? `${line} — ${ids.map((id) => `"${state.notes.find((note) => note.id === id)?.headline ?? id}"`).join(", ")}` : line;
@@ -1326,7 +1399,7 @@ server.registerTool(
   {
     title: "Leave a question, for now",
     description:
-      "Write the writer's word on a question the wall asks — \"leave it\" — so the reading stops asking it. Pass the question's kind as read_wall names it (sag, empty, unpaid, …) and, when that kind is asked more than once, its ids as read_wall lists them. The wall keeps the question and asks it again on its own the moment it would read differently — a card in it changes, a page moves, the median shifts — so a left question is never a dismissal; ask_again brings one back now. Only on the writer's word: never leave a question unasked.",
+      "Write the writer's word on a question the wall asks — \"leave it\" — so the reading stops asking it. Pass the question's kind as read_wall names it (sag, empty, unpaid, …) and, when that kind is asked more than once, its ids as read_wall lists them. A leave answers the reading in front of you: edits change the questions, so make the writer's changes first, read_wall, then leave what they still want left — a question that changed or went since the last reading is refused, with what it was. The wall keeps a left question and asks it again on its own the moment it would read differently — a card in it changes, a page moves, the median shifts — so a left question is never a dismissal; ask_again brings one back now. Only on the writer's word: never leave a question unasked.",
     inputSchema: { kind: z.string().min(1), ids: z.array(z.string()).optional() },
   },
   async (args) => {
@@ -1336,7 +1409,21 @@ server.registerTool(
     const matches = reading.findings.filter((finding) => finding.kind === args.kind && (!args.ids || sameList(finding.ids, args.ids)));
     if (matches.length === 0) {
       if (already.length) return ok(`Already left: [${args.kind}] ${already[0].text} It stays left until the question would read differently; ask_again brings it back.`);
-      return ok(`The wall is not asking a question of kind "${args.kind}"${args.ids ? ` about ids ${args.ids.join(", ")}` : ""}. read_wall lists the questions it asks now, each with its kind and ids.`);
+      // The reading the agent was answering, when the last read_wall had this question (round thirteen, entry 19).
+      const earlier = lastReading?.findings.find((finding) => finding.kind === args.kind && (!args.ids || sameList(finding.ids, args.ids)));
+      const now = reading.findings.filter((finding) => finding.kind === args.kind);
+      if (earlier) {
+        const since = sinceRead.length
+          ? `${sinceRead.length} change${sinceRead.length === 1 ? "" : "s"} landed since (${[...new Set(sinceRead)].join(", ")})`
+          : "the wall changed elsewhere since";
+        const state_ = now.length
+          ? `the wall now asks ${now.length === 1 ? "it differently" : `${now.length} questions of that kind`}: ${now.map((finding) => `${finding.text} (ids: ${finding.ids.join(", ")})`).join("; ")}`
+          : "the wall no longer asks it — the cards answered it";
+        return ok(
+          `Not left. When you last read the wall it asked [${earlier.kind}] ${earlier.text}${earlier.ids.length ? ` (ids: ${earlier.ids.join(", ")})` : ""}; ${since}, and ${state_}. A leave answers the reading in front of you: make the writer's edits first, read_wall, then leave what they still want left.`,
+        );
+      }
+      return ok(`The wall is not asking a question of kind "${args.kind}"${args.ids ? ` about ids ${args.ids.join(", ")}` : ""}. read_wall lists the questions it asks now, each with its kind and ids.${sinceRead.length ? ` ${sinceRead.length} change(s) landed since the last read_wall, so read it again first.` : ""}`);
     }
     if (matches.length > 1) {
       return ok(`The wall asks ${matches.length} questions of kind "${args.kind}"; pass ids to say which:\n${matches.map((finding) => `  - ${finding.text} (ids: ${finding.ids.join(", ")})`).join("\n")}`);
@@ -1392,46 +1479,41 @@ server.registerTool(
     if (!state.arrows.some(isFollows)) {
       return ok("The wall has no follows arrows, so there is no story order to move within: create_arrow the sequence first, or move_note the card by position.");
     }
-    const trailBefore = trail.length;
     let removed = 0;
     let drawn = 0;
-    let live = false;
-    const step = async (command) => {
-      const done = await commit(command);
-      if (done.changed) {
-        live = done.live;
-        if (command.type === "delete_arrow") removed += 1;
-        if (command.type === "create_arrow") drawn += 1;
-      }
-      return done;
-    };
-    // Leave: what pointed at the card points at what the card pointed at.
-    const ins = state.arrows.filter((arrow) => isFollows(arrow) && arrow.to === card.id);
-    const outs = state.arrows.filter((arrow) => isFollows(arrow) && arrow.from === card.id);
-    for (const arrow of [...ins, ...outs]) await step({ type: "delete_arrow", id: arrow.id });
-    for (const before of ins) for (const after of outs) if (before.from !== after.to) await step({ type: "create_arrow", from: before.from, to: after.to, kind: "follows" });
-    // Land: between the target and what followed it (or what led to it).
-    const { state: mid } = await readBoard();
-    if (args.after) {
-      for (const arrow of mid.arrows.filter((item) => isFollows(item) && item.from === target.id && item.to !== card.id)) {
-        await step({ type: "delete_arrow", id: arrow.id });
-        await step({ type: "create_arrow", from: card.id, to: arrow.to, kind: "follows" });
-      }
-      await step({ type: "create_arrow", from: target.id, to: card.id, kind: "follows" });
-    } else {
-      for (const arrow of mid.arrows.filter((item) => isFollows(item) && item.to === target.id && item.from !== card.id)) {
-        await step({ type: "delete_arrow", id: arrow.id });
-        await step({ type: "create_arrow", from: arrow.from, to: card.id, kind: "follows" });
+    // The whole move — its dozen arrows and the tidy — as one change: one frame on
+    // the bridge, one ⌘Z on the wall, one step for undo here.
+    const { state: final, live } = await commitAll(`move_scene "${card.headline}"`, (step, current) => {
+      const run = (command) => {
+        const done = step(command);
+        if (done.changed) {
+          if (command.type === "delete_arrow") removed += 1;
+          if (command.type === "create_arrow") drawn += 1;
+        }
+        return done;
+      };
+      // Leave: what pointed at the card points at what the card pointed at.
+      const ins = state.arrows.filter((arrow) => isFollows(arrow) && arrow.to === card.id);
+      const outs = state.arrows.filter((arrow) => isFollows(arrow) && arrow.from === card.id);
+      for (const arrow of [...ins, ...outs]) run({ type: "delete_arrow", id: arrow.id });
+      for (const before of ins) for (const after of outs) if (before.from !== after.to) run({ type: "create_arrow", from: before.from, to: after.to, kind: "follows" });
+      // Land: between the target and what followed it (or what led to it).
+      const mid = current();
+      if (args.after) {
+        for (const arrow of mid.arrows.filter((item) => isFollows(item) && item.from === target.id && item.to !== card.id)) {
+          run({ type: "delete_arrow", id: arrow.id });
+          run({ type: "create_arrow", from: card.id, to: arrow.to, kind: "follows" });
+        }
+        run({ type: "create_arrow", from: target.id, to: card.id, kind: "follows" });
+      } else {
+        for (const arrow of mid.arrows.filter((item) => isFollows(item) && item.to === target.id && item.from !== card.id)) {
+          run({ type: "delete_arrow", id: arrow.id });
+          run({ type: "create_arrow", from: arrow.from, to: card.id, kind: "follows" });
+        }
+        run({ type: "create_arrow", from: card.id, to: target.id, kind: "follows" });
       }
-      await step({ type: "create_arrow", from: card.id, to: target.id, kind: "follows" });
-    }
-    const { state: linked } = await readBoard();
-    const tidied = await step({ type: "apply_poses", poses: organizePoses(linked, {}) });
-    const final = tidied.state;
-    // One step for undo: the whole move, not its dozen arrows.
-    trail.splice(trailBefore);
-    trail.push({ before: state, after: canon(final), what: `move_scene "${card.headline}"` });
-    undone.length = 0;
+      run({ type: "apply_poses", poses: organizePoses(current(), {}) });
+    });
     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.` : "";
@@ -1605,23 +1687,65 @@ server.registerTool(
   {
     title: "Export the wall as Fountain",
     description:
-      "The open board as a Fountain screenplay: a title page (with the premise and logline in its notes), beats as sections, one scene per card in wall order — a forced heading from the card's place (or its headline), the headline as a synopsis, the cast and the fold as notes, the change line as action. Plain text a writer can open in any Fountain editor. Pass a path to write a .fountain file; otherwise the text comes back.",
+      "The open board as a Fountain screenplay: a title page (with the premise and logline in its notes), beats as sections, one scene per card in wall order — a forced heading from the card's place (or its headline), the headline as a synopsis, the cast and the fold as notes, the change line as action after the mark [Unwritten] until the scene is written. Titled for the project, a one-board film being its project. Plain text a writer can open in any Fountain editor. Pass a path to write a .fountain file; otherwise the text comes back.",
     inputSchema: { path: z.string().optional() },
   },
   async (args) => {
     const { state } = await readBoard();
     const { project } = await readProject();
     const board = project.boards.find((item) => item.id === project.activeBoardId);
-    const text = toFountain(state, {
-      title: board?.name,
-      project: project.boards.length > 1 && project.name !== "Untitled project" ? project.name : undefined,
-      premise: project.premise || undefined,
-      draftDate: new Date().toISOString(),
-    });
+    const titles = scriptTitles(project, board);
+    const text = toFountain(state, { ...titles, premise: project.premise || undefined, draftDate: new Date().toISOString() });
+    if (args.path) {
+      fs.mkdirSync(path.dirname(path.resolve(args.path)), { recursive: true });
+      fs.writeFileSync(args.path, text);
+      return ok(`Wrote ${text.split("\n").length} lines of Fountain, titled "${titles.title}", to ${args.path}.`);
+    }
+    return ok(text);
+  },
+);
+
+server.registerTool(
+  "export_markdown",
+  {
+    title: "Export the wall as Markdown",
+    description:
+      "The open board as Markdown, for a collaborator who lives in Google Docs or the like: titled for the project — a one-board film is its project, and the board's name follows only when the project has several boards — the premise and the logline under it, beats as second-level headings, a third-level heading per scene from its place with its scene number, the headline as a synopsis line, then the scene's text — a speech as its cue in bold with the lines under it — or, unwritten, its change line in italics after the mark [Unwritten], so a reader can tell a placeholder from a page. Pass a path to write a .md file; otherwise the text comes back.",
+    inputSchema: { path: z.string().optional() },
+  },
+  async (args) => {
+    const { state } = await readBoard();
+    const { project } = await readProject();
+    const board = project.boards.find((item) => item.id === project.activeBoardId);
+    const titles = scriptTitles(project, board);
+    const text = toMarkdown(state, { ...titles, premise: project.premise || undefined });
+    if (args.path) {
+      fs.mkdirSync(path.dirname(path.resolve(args.path)), { recursive: true });
+      fs.writeFileSync(args.path, text);
+      return ok(`Wrote ${text.split("\n").length} lines of Markdown, titled "${titles.title}", to ${path.resolve(args.path)}.`);
+    }
+    return ok(text);
+  },
+);
+
+server.registerTool(
+  "export_text",
+  {
+    title: "Export the script as plain text",
+    description:
+      "The open board's script as plain text, set as it prints: the paginator's lines at Courier's columns kept with spaces, scene numbers in both margins (the wall's order, or as locked), no page numbers, an unwritten scene's change line as action after the mark [Unwritten]. Titled for the project, a one-board film being its project. Pastes into anything and reads as a script wherever the font is monospaced. Pass a path to write a .txt file; otherwise the text comes back.",
+    inputSchema: { path: z.string().optional() },
+  },
+  async (args) => {
+    const { state } = await readBoard();
+    const { project } = await readProject();
+    const board = project.boards.find((item) => item.id === project.activeBoardId);
+    const titles = scriptTitles(project, board);
+    const text = toPlainText(state, titles);
     if (args.path) {
       fs.mkdirSync(path.dirname(path.resolve(args.path)), { recursive: true });
       fs.writeFileSync(args.path, text);
-      return ok(`Wrote ${text.split("\n").length} lines of Fountain to ${args.path}.`);
+      return ok(`Wrote ${text.split("\n").length} lines of plain text, titled "${titles.title}", to ${path.resolve(args.path)}.`);
     }
     return ok(text);
   },
@@ -1696,8 +1820,10 @@ server.registerTool(
     const { state } = await readBoard();
     const parsed = fromFountain(source);
     const { commands, matched } = mergeFountain(state, parsed);
-    let live = false;
-    for (const command of commands) ({ live } = await commit(command));
+    // The whole import as one change, so one undo takes every scene back.
+    const { live } = await commitAll(`import_fountain (${parsed.scenes.length} scene(s))`, (step) => {
+      for (const command of commands) step(command);
+    });
     const written = commands.filter((command) => command.type === "set_text").length;
     const created = matched.filter((item) => item.created).length;
     return ok(
@@ -1762,18 +1888,19 @@ server.registerTool(
   {
     title: "Export as Final Draft",
     description:
-      "The open board as a Final Draft .fdx: a heading per card with its scene number by wall order, the scene's text as script paragraphs (action, character, parenthetical, dialogue, dual dialogue, transition) or the change line as action when unwritten, and a title page. Pass a path to write the file; otherwise the XML comes back.",
+      "The open board as a Final Draft .fdx: a heading per card with its scene number by wall order, the scene's text as script paragraphs (action, character, parenthetical, dialogue, dual dialogue, transition) or the change line as action after the mark [Unwritten] when unwritten, and a title page for the project (a one-board film is its project). Pass a path to write the file; otherwise the XML comes back.",
     inputSchema: { path: z.string().optional() },
   },
   async (args) => {
     const { state } = await readBoard();
     const { project } = await readProject();
     const board = project.boards.find((item) => item.id === project.activeBoardId);
-    const xml = toFdx(state, { title: board?.name, project: project.boards.length > 1 ? project.name : undefined, draftDate: new Date().toISOString() });
+    const titles = scriptTitles(project, board);
+    const xml = toFdx(state, { ...titles, draftDate: new Date().toISOString() });
     if (args.path) {
       fs.mkdirSync(path.dirname(path.resolve(args.path)), { recursive: true });
       fs.writeFileSync(args.path, xml);
-      return ok(`Wrote a Final Draft file with ${state.notes.length} scene(s) to ${args.path}.`);
+      return ok(`Wrote a Final Draft file with ${state.notes.length} scene(s), titled "${titles.title}", to ${args.path}.`);
     }
     return ok(xml);
   },
@@ -1793,8 +1920,10 @@ server.registerTool(
     const { state } = await readBoard();
     const parsed = fromFdx(source);
     const { commands, matched } = mergeFountain(state, parsed);
-    let live = false;
-    for (const command of commands) ({ live } = await commit(command));
+    // The whole import as one change, so one undo takes every scene back.
+    const { live } = await commitAll(`import_fdx (${parsed.scenes.length} scene(s))`, (step) => {
+      for (const command of commands) step(command);
+    });
     const written = commands.filter((command) => command.type === "set_text").length;
     const created = matched.filter((item) => item.created).length;
     const receipt = describeSetAside(parsed.setAside);
@@ -2107,39 +2236,40 @@ server.registerTool(
     },
   },
   async (args) => {
-    let { result, live, changed } = await commit({
-      type: "set_plant",
-      ids: args.ids,
-      plants: args.plants,
-    });
-    let laterLine = "";
+    // 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;
+    let forgetting = false;
     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));
+      const { boardId: current } = await readBoard();
       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.";
-        }
+        forgetting = true;
       } else {
-        const target = findBoard(project, args.later);
+        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;
+      }
+    }
+    // The fold and the board it pays off on land as one change: one ⌘Z on the wall.
+    const { value, live, changed } = await commitAll("set_plant", (step, current) => {
+      let { result } = step({ type: "set_plant", ids: args.ids, plants: args.plants });
+      let laterLine = "";
+      if (forgetting) {
+        const cleared = step({ type: "set_payoff_board", ids: args.ids, boardId: null });
+        if (cleared.changed) {
+          result = cleared.result;
+          laterLine = " The board it paid off on is forgotten; read_wall asks again until a setup arrow or a board pays it off.";
         }
+      } else if (target) {
+        const named = step({ type: "set_payoff_board", ids: args.ids, boardId: target.id });
+        if (named.changed) result = named.result;
+        const here = current().notes.filter((note) => args.ids.includes(note.id));
         laterLine = ` ${here.length} card(s) pay off later, on "${target.name}": read_wall stops asking where they come back, and the card says so.`;
       }
-    }
+      return { result, laterLine };
+    });
+    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.");
     return ok(
@@ -2411,6 +2541,29 @@ server.registerTool(
   },
 );
 
+server.registerTool(
+  "add_to_group",
+  {
+    title: "Add cards to a group",
+    description:
+      "Put one or more cards into a group that already exists — the agent's side of dragging a card into a frame. The frame reaches the cards where they are; nothing moves. A card is in one group at a time, so it leaves any other frame on the way, and a frame left with one card dissolves. Needs the group's id and the cards' ids from list_board; organize keeps a group together as a block.",
+    inputSchema: { id: z.string(), noteIds: z.array(z.string()).min(1) },
+  },
+  async (args) => {
+    const { state, changed, result, live } = await commit({ type: "add_to_group", id: args.id, noteIds: args.noteIds });
+    if (!changed) {
+      if (!state.groups.some((group) => group.id === args.id)) return ok(`No group with id ${args.id}. Call list_board for the real ids; create_group makes a new frame.`);
+      const missing = args.noteIds.filter((id) => !state.notes.some((note) => note.id === id));
+      return ok(missing.length ? `Nothing added: not on the board — ${missing.join(", ")}. Call list_board to check the ids.` : "Nothing added: those cards are in that group already.");
+    }
+    const names = result.added.map((id) => `"${state.notes.find((note) => note.id === id)?.headline ?? id}"`).join(", ");
+    const left = result.left
+      .map((group) => (group.dissolved ? ` "${group.title}" dissolved on the way: a frame needs two cards.` : ` Left "${group.title}", which keeps ${group.remaining} card${group.remaining === 1 ? "" : "s"}.`))
+      .join("");
+    return ok(`Added ${names} to "${result.group.title}", which now holds ${result.group.noteIds.length} cards${where(live)}. The frame reaches them where they are; organize lays the group out as a block.${left}`, result);
+  },
+);
+
 server.registerTool(
   "rename_group",
   {

package/src/board/fdx.js

@@ -12,7 +12,7 @@
 
 import { parseScene, TRANSITION } from "./paginate.js";
 import { readingOrder } from "./readWall.js";
-import { sceneHeading } from "./fountain.js";
+import { sceneHeading, standInFor } from "./fountain.js";
 import { sceneNumbers } from "./numbering.js";
 
 function escapeXml(text) {
@@ -60,7 +60,8 @@ export function toFdx(state, options = {}) {
       "<Text>",
       `<SceneProperties Length="" Page="" Title="${escapeXml(note.headline)}" />\n      <Text>`,
     );
-    const elements = parseScene(note.text && note.text.trim() ? note.text : note.change || "");
+    // Unwritten: the change line stands in as action, marked as every export marks it.
+    const elements = parseScene(note.text && note.text.trim() ? note.text : standInFor(note));
     for (let i = 0; i < elements.length; i += 1) {
       const element = elements[i];
       if (element.kind === "action") content += paragraph("Action", element.text);

package/src/board/fountain.d.ts

@@ -3,6 +3,10 @@
 import type { BoardNote, BoardState } from "./reducer";
 
 export declare function sceneHeading(note: BoardNote): string;
+/** The mark every export sets before an unwritten scene's change line. */
+export declare const UNWRITTEN_MARK: string;
+export declare function standInFor(note: Pick<BoardNote, "change">): string;
+export declare function unmark(text: string | null | undefined): { text: string; marked: boolean };
 
 export declare function titlePage(titles: {
   title?: string;

package/src/board/fountain.js

@@ -26,6 +26,28 @@ export function sceneHeading(note) {
   return `.${upper(words)}`;
 }
 
+/**
+ * The mark every export sets before an unwritten scene's change line, so a
+ * reader can tell a placeholder from a page (round thirteen, entry 27). One
+ * mark, the same words in Markdown, plain text, Fountain and Final Draft;
+ * coming back in, a body that is the mark and the card's change line is
+ * still unwritten.
+ */
+export const UNWRITTEN_MARK = "[Unwritten]";
+
+/** What stands in for an unwritten scene's body: the mark, then the change line. */
+export function standInFor(note) {
+  const change = (note.change ?? "").trim();
+  return change ? `${UNWRITTEN_MARK} ${change}` : UNWRITTEN_MARK;
+}
+
+/** A body without its mark, and whether it carried one. */
+export function unmark(text) {
+  const trimmed = (text ?? "").trim();
+  if (!trimmed.startsWith(UNWRITTEN_MARK)) return { text: trimmed, marked: false };
+  return { text: trimmed.slice(UNWRITTEN_MARK.length).trim(), marked: true };
+}
+
 /** The title page block. `titles` is what the writer would put above the script. */
 export function titlePage({ title, credit, author, draftDate, notes }) {
   const lines = [];
@@ -89,8 +111,9 @@ export function toFountain(state, options = {}) {
       body.push(`[[${marks.join(" · ")}]]`);
       body.push("");
     }
-    // The scene's text when it is written; the change line stands in until then.
-    body.push(note.text && note.text.trim() ? note.text.trim() : note.change || "");
+    // The scene's text when it is written; the change line stands in until
+    // then, marked so a printed page never passes a placeholder off as a scene.
+    body.push(note.text && note.text.trim() ? note.text.trim() : standInFor(note));
     body.push("");
   }
 
@@ -206,9 +229,10 @@ export function mergeFountain(state, parsed) {
     if (found) {
       used.add(found.id);
       cursor = order.indexOf(found) + 1;
-      // A scene whose body is the card's own change line is the export of an
-      // unwritten card coming back: still unwritten, not a page.
-      const standIn = !(found.text ?? "").trim() && sameWords(scene.text, found.change ?? "");
+      // A scene whose body is the mark, or the card's own change line, is the
+      // export of an unwritten card coming back: still unwritten, not a page.
+      const body = unmark(scene.text);
+      const standIn = !(found.text ?? "").trim() && (body.marked || sameWords(body.text, found.change ?? ""));
       if ((found.text ?? "") !== scene.text && !standIn) {
         commands.push({ type: "set_text", id: found.id, text: scene.text });
       }
@@ -220,13 +244,15 @@ export function mergeFountain(state, parsed) {
     const headline = scene.synopsis || titleCase(scene.heading);
     const isPlace = scene.forced && Boolean(scene.synopsis);
     const id = `scene-${Math.random().toString(36).slice(2, 8)}`;
+    // A marked body is an unwritten scene: its words are the change line, not a page.
+    const body = unmark(scene.text);
     commands.push({
       type: "create_note",
       id,
       headline,
-      change: scene.text ? firstSentence(scene.text) : "What changes?",
+      change: body.marked ? body.text || "What changes?" : scene.text ? firstSentence(scene.text) : "What changes?",
       location: isPlace ? titleCase(scene.heading) : "",
-      text: scene.text,
+      text: body.marked ? "" : scene.text,
       x: anchor ? anchor.x + 40 : 140,
       y: anchor ? anchor.y + 40 : 140,
     });

package/src/board/markdown.d.ts

@@ -0,0 +1,15 @@
+import type { Line } from "./paginate";
+import type { BoardState } from "./reducer";
+
+/** What a document carries above the script: the board's name, the project's when it has several boards, the premise. */
+export type TakeOptions = { title?: string; project?: string; premise?: string };
+
+/** The wall as Markdown (R54): title, premise, logline, beats as headings, a heading per scene, the text or the change line. */
+export declare function toMarkdown(state: BoardState, options?: TakeOptions): string;
+
+/** The script as plain text, set as it prints: Courier's columns kept with spaces, scene numbers in the margins. */
+export declare function toPlainText(state: BoardState, options?: TakeOptions): string;
+
+export declare const GUTTER: number;
+export declare const COLUMN: Record<"character" | "more" | "parenthetical" | "dialogue", number>;
+export declare function setLine(line: Line): string;

package/src/board/markdown.js

@@ -0,0 +1,179 @@
+// Take the pages with you (R54): the wall as Markdown, and the script as
+// plain text — for a collaborator who lives in Google Docs rather than in a
+// screenwriting app. Both are pure and shared by every door: the Pages
+// panel's sheet, the console, and the MCP server's export_markdown and
+// export_text.
+//
+// Markdown is the wall read out, in wall order: the board as the title, the
+// premise and the logline under it, beats as second-level headings, one
+// third-level heading per scene from its place (with its scene number, locked
+// or by wall order), the headline as a synopsis line, then the scene's text —
+// set by what each element is, from the same rules the paginator reads by —
+// or, unwritten, its change line. Nothing invisible: Markdown has no notes
+// that print as nothing, so the cast and the fold stay on the wall.
+//
+// Plain text is the script as it prints: the paginator's lines, Courier's
+// columns kept with spaces, scene numbers in both margins, no page numbers.
+// It pastes into anything and reads as a script wherever the font is
+// monospaced.
+
+import { readingOrder } from "./readWall.js";
+import { sceneHeading, standInFor } from "./fountain.js";
+import { paginate, parseScene, WIDTH } from "./paginate.js";
+import { sceneNumbers } from "./numbering.js";
+
+function upper(text) {
+  return text.trim().replace(/\s+/g, " ").toUpperCase();
+}
+
+function documentTitle(options) {
+  const title = options.title || "Untitled";
+  return options.project && options.project !== title ? `${options.project} · ${title}` : title;
+}
+
+/** A scene's text as Markdown paragraphs: action as it is, a speech as its cue in bold with the lines hard-broken under it. */
+function sceneMarkdown(text) {
+  const out = [];
+  for (const element of parseScene(text)) {
+    switch (element.kind) {
+      case "break":
+        out.push("---", "");
+        break;
+      case "speech": {
+        const lines = [`**${element.name}**`];
+        for (const part of element.parts) lines.push(part.kind === "parenthetical" ? `*${part.text}*` : part.text);
+        // Two trailing spaces: Markdown's line break, so the cue and its lines stay on their own lines.
+        out.push(lines.join("  \n"), "");
+        break;
+      }
+      case "centered":
+      case "transition":
+      case "action":
+      default:
+        out.push(element.text, "");
+    }
+  }
+  return out;
+}
+
+/**
+ * The whole wall as Markdown.
+ *
+ * @param state the board
+ * @param options.title the board's name; options.project the project's name
+ *   when the project has several boards; options.premise
+ */
+export function toMarkdown(state, options = {}) {
+  const order = readingOrder(state.notes);
+  const numbers = sceneNumbers(order, state.lock);
+  const out = [`# ${documentTitle(options)}`, ""];
+  if (options.premise) out.push(`*${options.premise}*`, "");
+  if (state.logline) out.push(`**${state.logline}**`, "");
+  let beat = 0;
+  for (const note of order) {
+    if (note.rank === "beat") {
+      beat += 1;
+      out.push(`## ${beat}. ${note.headline || "Untitled beat"}`, "");
+    }
+    const heading = sceneHeading(note).slice(1);
+    out.push(`### ${numbers.get(note.id) ?? ""} · ${heading}`.replace(/^###  · /, "### "), "");
+    if (note.headline && upper(note.headline) !== heading) out.push(`*${note.headline.trim()}*`, "");
+    if (note.text && note.text.trim()) out.push(...sceneMarkdown(note.text));
+    // Unwritten: the change line stands in, marked and in italics, so a reader
+    // in Docs can tell the one written scene from sixteen placeholders.
+    else out.push(`*${standInFor(note)}*`, "");
+  }
+  return `${out.join("\n").trimEnd()}\n`;
+}
+
+/** The column the script's body starts at: room for a scene number on the left. */
+export const GUTTER = 5;
+
+/** Where each kind of line starts, in characters from the body's left edge — the print stylesheet's columns. */
+export const COLUMN = { character: 22, more: 22, parenthetical: 16, dialogue: 10 };
+
+const DUAL_RIGHT = 32;
+const DUAL_CUE = 8;
+
+function pad(n) {
+  return " ".repeat(Math.max(0, n));
+}
+
+function centred(text, width = WIDTH.action) {
+  return pad(GUTTER + Math.floor((width - text.length) / 2)) + text;
+}
+
+/** One line of a dual-dialogue column, from the column's own left edge. */
+function columnLine(line) {
+  if (!line || line.kind === "blank") return "";
+  const text = line.text ?? "";
+  if (line.kind === "character") return pad(DUAL_CUE) + text;
+  if (line.kind === "parenthetical") return pad(4) + text;
+  return text;
+}
+
+/** A printed line set with spaces. Exported for the test; the file is `toPlainText`. */
+export function setLine(line) {
+  const text = line.text ?? "";
+  switch (line.kind) {
+    case "blank":
+      return "";
+    case "heading": {
+      const number = line.sceneNumber === null || line.sceneNumber === undefined ? "" : String(line.sceneNumber);
+      if (!number) return pad(GUTTER) + text;
+      return `${number.padEnd(GUTTER)}${text.padEnd(WIDTH.action)} ${number}`.trimEnd();
+    }
+    case "character":
+    case "more":
+    case "parenthetical":
+    case "dialogue":
+      return pad(GUTTER + COLUMN[line.kind]) + text;
+    case "transition":
+      return pad(GUTTER + WIDTH.action - text.length) + text;
+    case "centered":
+      return centred(text);
+    case "dual": {
+      const left = pad(GUTTER) + columnLine(line.left);
+      const right = columnLine(line.right);
+      return right ? `${left.padEnd(GUTTER + DUAL_RIGHT)}${right}` : left.trimEnd();
+    }
+    case "action":
+    default:
+      return pad(GUTTER) + text;
+  }
+}
+
+/**
+ * The script as plain text, set as it prints.
+ *
+ * @param state the board
+ * @param options.title the board's name; options.project the project's name
+ *   when the project has several boards
+ */
+export function toPlainText(state, options = {}) {
+  const order = readingOrder(state.notes);
+  const numbers = sceneNumbers(order, state.lock);
+  const result = paginate(
+    order.map((note) => ({
+      id: note.id,
+      heading: sceneHeading(note).slice(1),
+      text: note.text,
+      change: standInFor(note),
+      written: Boolean(note.text && note.text.trim()),
+      number: numbers.get(note.id) ?? undefined,
+    })),
+  );
+  const title = options.title || "Untitled";
+  const out = [];
+  if (options.project && options.project !== title) {
+    out.push(centred(upper(options.project)), "", centred(title));
+  } else {
+    out.push(centred(upper(title)));
+  }
+  out.push("", "");
+  for (const page of result.pages) {
+    if (page.number > 1) out.push("");
+    for (const line of page.lines) out.push(setLine(line));
+  }
+  return `${out.join("\n").replace(/\n{4,}/g, "\n\n\n").trimEnd()}\n`;
+}

package/src/board/project.d.ts

@@ -67,6 +67,8 @@ export declare function setActiveBoard(project: ProjectRecord, id: string, now?:
 export declare function renameProject(project: ProjectRecord, name: string, now?: string): ProjectRecord;
 export declare function setPremise(project: ProjectRecord, premise: 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; project?: string };
 export declare function findBoard(project: ProjectRecord, key: string): BoardMeta | null;
 export declare function reidentifyProject(
   project: ProjectRecord,

package/src/board/project.js

@@ -289,6 +289,21 @@ export function setPremise(project, premise, now = nowIso()) {
   return touch(project, { premise: next }, now);
 }
 
+/**
+ * What a script going out is called (round thirteen, entry 26): a named
+ * project is the title — a one-board film is its project — with the board's
+ * name beside it only when the project has several boards; an untitled
+ * project's board is the title. One rule for Markdown, plain text, Fountain
+ * and Final Draft, through every door.
+ */
+export function scriptTitles(project, board) {
+  const boardName = (board?.name ?? "").trim() || "Untitled";
+  const named = typeof project?.name === "string" && project.name.trim() && project.name !== DEFAULT_PROJECT_NAME;
+  if (!named) return { title: boardName };
+  if ((project.boards ?? []).length > 1) return { title: boardName, project: project.name };
+  return { title: project.name };
+}
+
 export function boardById(project, id) {
   return project.boards.find((board) => board.id === id) ?? null;
 }

package/src/board/reducer.d.ts

@@ -139,7 +139,7 @@ export declare function sameName(a: string, b: string): boolean;
 export type Command =
   | { type: "set_logline"; logline: string }
   | { type: "set_rank"; ids: string[]; rank: NoteRank }
-  | { type: "set_length"; ids: string[]; lengthEighths: number }
+  | { type: "set_length"; ids: string[]; lengthEighths: number | null }
   | { type: "set_target"; targetEighths: number }
   | {
       type: "create_note";
@@ -167,6 +167,7 @@ export type Command =
   | { type: "settle_note"; id: string }
   | { type: "create_group"; title?: string; noteIds: string[] }
   | { type: "ungroup"; id: string }
+  | { type: "add_to_group"; id: string; noteIds: string[] }
   | { type: "rename_group"; id: string; title: string }
   | { type: "create_arrow"; from: string; to: string; kind?: ArrowKind }
   | { type: "delete_arrow"; id: string }

package/src/board/reducer.js

@@ -497,11 +497,12 @@ export function applyCommand(state, command, now = nowIso()) {
     case "set_length": {
       const ids = new Set(command.ids);
       if (ids.size === 0) return { state, changed: false };
-      const lengthEighths = clampEighths(
-        command.lengthEighths,
-        DEFAULT_NOTE_EIGHTHS,
-        MAX_NOTE_EIGHTHS,
-      );
+      // null unsizes: the card claims nothing again and reads as about a page
+      // (round thirteen, entry 16: there was no way back from a length).
+      const lengthEighths =
+        command.lengthEighths === null
+          ? null
+          : clampEighths(command.lengthEighths, DEFAULT_NOTE_EIGHTHS, MAX_NOTE_EIGHTHS);
       const touched = [];
       const notes = state.notes.map((note) => {
         if (!ids.has(note.id) || note.lengthEighths === lengthEighths) return note;
@@ -575,23 +576,32 @@ export function applyCommand(state, command, now = nowIso()) {
     }
 
     case "delete_note": {
-      if (!state.notes.some((note) => note.id === command.id)) {
-        return { state, changed: false };
-      }
+      const gone = state.notes.find((note) => note.id === command.id);
+      if (!gone) return { state, changed: false };
+      const headlineOf = (id) => state.notes.find((note) => note.id === id)?.headline ?? id;
       const notes = state.notes.filter((note) => note.id !== command.id);
-      const arrows = state.arrows.filter(
-        (arrow) => arrow.from !== command.id && arrow.to !== command.id,
-      );
+      const taken = state.arrows.filter((arrow) => arrow.from === command.id || arrow.to === command.id);
+      const arrows = state.arrows.filter((arrow) => !taken.includes(arrow));
+      const left = [];
       const groups = pruneGroups(
-        state.groups.map((group) => ({
-          ...group,
-          noteIds: group.noteIds.filter((id) => id !== command.id),
-        })),
+        state.groups.map((group) => {
+          if (!group.noteIds.includes(command.id)) return group;
+          const noteIds = group.noteIds.filter((id) => id !== command.id);
+          left.push({ id: group.id, title: group.title, remaining: noteIds.length, dissolved: noteIds.length < 2 });
+          return { ...group, noteIds };
+        }),
       );
+      // The result says what went with the card, so a door can say it too
+      // (round thirteen, entry 17: "Deleted card." and nothing of the arrows).
       return {
         state: { ...state, notes, arrows, groups },
         changed: true,
-        result: { id: command.id },
+        result: {
+          id: command.id,
+          headline: gone.headline,
+          arrows: taken.map((arrow) => ({ ...arrow, fromHeadline: headlineOf(arrow.from), toHeadline: headlineOf(arrow.to) })),
+          groups: left,
+        },
       };
     }
 
@@ -672,6 +682,34 @@ export function applyCommand(state, command, now = nowIso()) {
       };
     }
 
+    case "add_to_group": {
+      // The agent's twin of dragging a card into a frame (round thirteen,
+      // entry 18). Membership only: the frame reaches the card where it is,
+      // and a card leaves any other group on the way, as create_group does.
+      const group = state.groups.find((item) => item.id === command.id);
+      if (!group) return { state, changed: false };
+      const joining = command.noteIds.filter(
+        (id, index) =>
+          command.noteIds.indexOf(id) === index &&
+          !group.noteIds.includes(id) &&
+          state.notes.some((note) => note.id === id),
+      );
+      if (joining.length === 0) return { state, changed: false };
+      const idSet = new Set(joining);
+      const left = [];
+      const groups = pruneGroups(
+        state.groups.map((existing) => {
+          if (existing.id === group.id) return { ...existing, noteIds: [...existing.noteIds, ...joining] };
+          if (!existing.noteIds.some((id) => idSet.has(id))) return existing;
+          const noteIds = existing.noteIds.filter((id) => !idSet.has(id));
+          left.push({ id: existing.id, title: existing.title, remaining: noteIds.length, dissolved: noteIds.length < 2 });
+          return { ...existing, noteIds };
+        }),
+      );
+      const joined = groups.find((item) => item.id === group.id);
+      return { state: { ...state, groups }, changed: true, result: { group: joined, added: joining, left } };
+    }
+
     case "rename_group": {
       let renamed = false;
       const groups = state.groups.map((group) => {