plotcoder-board 0.1.14 → 0.1.15

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-seven 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 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. Twelve rounds have been run, the first three through a
+repo checkout and the rest through the account door, and every finding they
+logged is fixed. [`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.14. 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.15",
   "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";
@@ -698,7 +699,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);
@@ -792,6 +804,35 @@ async function commit(command) {
   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 });
+  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) {
@@ -1106,45 +1147,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"}`,
@@ -1392,46 +1435,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.` : "";
@@ -1627,6 +1665,57 @@ server.registerTool(
   },
 );
 
+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: the board as the title (the project's name before it 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. 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 text = toMarkdown(state, {
+      title: board?.name,
+      project: project.boards.length > 1 && project.name !== "Untitled project" ? project.name : undefined,
+      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 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. 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 text = toPlainText(state, {
+      title: board?.name,
+      project: project.boards.length > 1 && project.name !== "Untitled project" ? project.name : 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 plain text to ${path.resolve(args.path)}.`);
+    }
+    return ok(text);
+  },
+);
+
 server.registerTool(
   "write_scene",
   {
@@ -1696,8 +1785,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(
@@ -1793,8 +1884,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 +2200,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(

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,177 @@
+// 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 } 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));
+    else if (note.change && note.change.trim()) out.push(note.change.trim(), "");
+  }
+  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: note.change,
+      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`;
+}