plotcoder-board 0.1.13 → 0.1.15

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";
@@ -51,6 +52,7 @@ import { segmentBrief, WORKFLOWS } from "../src/board/workflows.js";
 import { DEFAULT_REMINDERS, titleFromBody } from "../src/board/reminders.js";
 import crypto from "node:crypto";
 import { describeRuns, describeSetups, readWall } from "../src/board/readWall.js";
+import { compareStructure, describeComparison, MATCH_PAGES } from "../src/board/compareStructure.js";
 import { GAP, ROW_WIDTH, organizePoses } from "../src/board/organize.js";
 import { sceneLineCount } from "../src/board/paginate.js";
 import {
@@ -69,6 +71,11 @@ import {
   structureBeats,
   reidentifyProject,
   renameProject,
+  castElsewhere,
+  liftCast,
+  mergeRoster,
+  sameRoster,
+  withRoster,
 } from "../src/board/project.js";
 
 /**
@@ -626,7 +633,23 @@ async function openBoardEverywhere(project, boards, projectRev, base, boardId) {
   return { project: opened, state, live };
 }
 
+/**
+ * The open board with the project's cast in it (R51). A project written
+ * before the cast moved to the record is lifted once, here, and written back.
+ */
 async function readBoard() {
+  const raw = await readBoardRaw();
+  const held = await readProject();
+  if (!Array.isArray(held.project.characters)) {
+    const boardId = raw.boardId ?? held.project.activeBoardId;
+    const lifted = liftCast(held.project, { ...held.boards, [boardId]: raw.state });
+    await writeProject(lifted.project, lifted.boards, held.rev, held.base);
+    return { ...raw, state: lifted.boards[boardId] ?? withRoster(raw.state, lifted.project) };
+  }
+  return { ...raw, state: withRoster(raw.state, held.project) };
+}
+
+async function readBoardRaw() {
   const viaAccount = await throughAccount(accountReadBoard);
   if (viaAccount) return viaAccount;
   const base = await findBridge();
@@ -653,7 +676,47 @@ async function readBoard() {
   return { ...file, base: null, live: false };
 }
 
-async function writeBoard(next, rev, base, boardId = null) {
+/**
+ * Write the board, keeping the project's cast (R51) with it. A kernel
+ * command's result ("exact": commit, undo, redo) is the roster as the writer
+ * now wants it, removals included, and it is lifted onto the record. Any
+ * other state — a board opened, a file imported — joins the cast without
+ * shrinking it ("merge"), and is written composed with the record.
+ */
+async function writeBoard(next, rev, base, boardId = null, roster = "merge") {
+  const held = await readProject();
+  let toWrite = next;
+  if (Array.isArray(held.project.characters)) {
+    let project = held.project;
+    if (roster === "exact") {
+      if (!sameRoster(project.characters, next.characters)) project = { ...project, characters: next.characters, updatedAt: new Date().toISOString() };
+    } else {
+      const merged = mergeRoster(project, next);
+      project = merged.project;
+      toWrite = merged.state;
+    }
+    if (project !== held.project) {
+      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);
+}
+
+async function writeBoardRaw(next, rev, base, boardId = null) {
   if (base === ACCOUNT) return accountWriteBoard(next, rev, boardId);
   if (base) {
     try {
@@ -734,13 +797,42 @@ async function commit(command) {
   // command teaches the agent the board is in a state it is not.
   if (!changed) return { state: next, changed, result, live: base !== null };
 
-  const live = await writeBoard(next, rev, base, boardId);
+  const live = await writeBoard(next, rev, base, boardId, "exact");
   trail.push({ before: state, after: canon(next), what: 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 });
+  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) {
@@ -873,7 +965,7 @@ function summarize(state) {
       ? `runtime: about ${formatPages(runtime)} pages (an estimate from the cards; a page runs about a minute); no target set — set_target for a pilot (60) or a half-hour (30); against the feature default of 120 it would be ${formatPages(-over)} under`
       : `runtime: about ${formatPages(runtime)} pages of a ${formatPages(state.targetEighths)}-page target — ${over > 0 ? `${formatPages(over)} over` : over < 0 ? `${formatPages(-over)} under` : "on it"} (an estimate from the cards; a page runs about a minute)`,
     `notes: ${state.notes.length}, groups: ${state.groups.length}, arrows: ${state.arrows.length}, cast: ${state.characters.length}`,
-    "cast:",
+    "cast (the project's; every board of it casts from here):",
     cast || "  (no one yet — add_character to start the roster)",
     "places (each phrase is its own place, and the app relates none of them — if two are one place, set_location them the same):",
     places || "  (no card says where it happens yet)",
@@ -1055,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"}`,
@@ -1188,14 +1282,16 @@ server.registerTool(
   {
     title: "Read the wall",
     description:
-      "Read the board back: the beats in wall order (rows top to bottom, cards left to right), the pages of scenes between consecutive beats with the cards in each, every setup with the distance to its payoff, and the questions the wall raises — no beat marked yet; a run out of proportion with the others; beats back to back with nothing between them (a chain of them is one question); a card with a placeholder headline or no change line; a card no arrow touches; two headlines that read like the same scene; a group too long to be one sequence; a person in the cast on no card; a person gone for more than a third of the story and ten pages; a payoff before its setup on the wall; a folded card no setup arrow pays off; cards that say no place once any card has one. These are questions, not fixes: put them to the writer and do not act on them unasked. It says nothing about how many beats there should be, and neither should you. The prose carries every id; the JSON after it is the same reading for a program, and PLOTCODER_JSON=0 in the server's environment drops it.",
+      "Read the board back: the beats in wall order (rows top to bottom, cards left to right), the pages of scenes between consecutive beats with the cards in each, every setup with the distance to its payoff, and the questions the wall raises — no beat marked yet; a run out of proportion with the others; beats back to back with nothing between them (a chain of them is one question); a card with a placeholder headline or no change line; a card no arrow touches; two headlines that read like the same scene; a group too long to be one sequence; a person in the cast on no card; a person gone for more than a third of the story and ten pages; a payoff before its setup on the wall; a folded card no setup arrow pays off; cards that say no place once any card has one. These are questions, not fixes: put them to the writer and do not act on them unasked. A question the writer answers with \"leave it\" is left with leave_question and listed under \"left, for now\" instead, until it would read differently. It says nothing about how many beats there should be, and neither should you. The prose carries every id; the JSON after it is the same reading for a program, and PLOTCODER_JSON=0 in the server's environment drops it.",
     inputSchema: {},
   },
   async () => {
     const { state, live, base, boardId: readBoardId } = await readBoard();
     const { project: projectForRead } = await readProject();
     const readBoardMeta = boardById(projectForRead, readBoardId ?? projectForRead.activeBoardId);
-    const reading = readWall(state);
+    const { boards: boardsForRead } = await readProject();
+    const elsewhereForRead = castElsewhere(projectForRead, boardsForRead, readBoardId ?? projectForRead.activeBoardId);
+    const reading = readWall(state, { elsewhere: Object.keys(elsewhereForRead) });
     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;
@@ -1238,13 +1334,20 @@ server.registerTool(
       "questions the wall raises:",
       ...(reading.findings.length
         ? reading.findings.map((finding) => `  - [${finding.kind}] ${finding.text}${finding.ids.length ? ` (ids: ${finding.ids.join(", ")})` : ""}`)
-        : ["  (none that this reading can see)"]),
+        : [reading.left.length ? "  (none the writer has not left)" : "  (none that this reading can see)"]),
+      ...(reading.left.length
+        ? [
+            "left, for now (the writer's word; kept until the question would read differently, and ask_again brings one back):",
+            ...reading.left.map((finding) => `  - [${finding.kind}] ${finding.text} (left ${String(finding.since).slice(0, 10)}${finding.ids.length ? `; ids: ${finding.ids.join(", ")}` : ""})`),
+          ]
+        : []),
       `checks: ${CHECKS.length} run — ${(() => {
         const asked = reading.findings;
-        if (asked.length === 0) return "asking nothing";
+        const held = reading.left.length ? `, ${reading.left.length} left by the writer` : "";
+        if (asked.length === 0) return `asking nothing${held}`;
         const counts = new Map();
         for (const finding of asked) counts.set(finding.kind, (counts.get(finding.kind) ?? 0) + 1);
-        return `asking ${asked.length} question${asked.length === 1 ? "" : "s"} of ${counts.size} kind${counts.size === 1 ? "" : "s"}: ${[...counts.entries()].map(([kind, n]) => (n > 1 ? `${kind} ×${n}` : kind)).join(", ")}`;
+        return `asking ${asked.length} question${asked.length === 1 ? "" : "s"} of ${counts.size} kind${counts.size === 1 ? "" : "s"}: ${[...counts.entries()].map(([kind, n]) => (n > 1 ? `${kind} ×${n}` : kind)).join(", ")}${held}`;
       })()}; checked and clean: ${CHECKS.filter((kind) => !reading.findings.some((finding) => finding.kind === kind)).map((kind) => {
         if (kind === "unlinked" && state.arrows.length === 0) return "no card without an arrow (not asked: no arrows yet)";
         if (kind === "unplaced" && !state.notes.some((note) => (note.location ?? "").trim())) return "no card without a place (not asked: no card placed yet)";
@@ -1257,6 +1360,60 @@ server.registerTool(
   },
 );
 
+// --- Leaving a question (R53) ----------------------------------------
+
+const sameList = (a, b) => a.length === b.length && a.every((id, index) => id === b[index]);
+
+server.registerTool(
+  "leave_question",
+  {
+    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.",
+    inputSchema: { kind: z.string().min(1), ids: z.array(z.string()).optional() },
+  },
+  async (args) => {
+    const { state } = await readBoard();
+    const reading = readWall(state);
+    const already = reading.left.filter((finding) => finding.kind === args.kind && (!args.ids || sameList(finding.ids, args.ids)));
+    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.`);
+    }
+    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")}`);
+    }
+    const finding = matches[0];
+    const { result, live } = await commit({ type: "leave_question", kind: finding.kind, ids: finding.ids, text: finding.text });
+    return ok(
+      `Left, for now: [${finding.kind}] ${finding.text}${where(live)} The wall stops asking it and keeps the writer's word; it asks again on its own when the question would read differently, and ask_again brings it back now. read_wall lists it under "left, for now".`,
+      result,
+    );
+  },
+);
+
+server.registerTool(
+  "ask_again",
+  {
+    title: "Ask a left question again",
+    description: "Take back a left question by its kind (and ids, when that kind was left more than once), so the wall asks it again now. Without ids, every left question of that kind comes back.",
+    inputSchema: { kind: z.string().min(1), ids: z.array(z.string()).optional() },
+  },
+  async (args) => {
+    const { state } = await readBoard();
+    const held = (state.left ?? []).filter((item) => item.kind === args.kind && (!args.ids || sameList(item.ids, args.ids)));
+    if (held.length === 0) return ok(`Nothing of kind "${args.kind}"${args.ids ? ` about ids ${args.ids.join(", ")}` : ""} is left. read_wall lists what is, under "left, for now".`);
+    const { result, live } = await commit({ type: "ask_again", kind: args.kind, ids: args.ids });
+    const reading = readWall((await readBoard()).state);
+    const back = reading.findings.filter((finding) => held.some((item) => item.kind === finding.kind && sameList(item.ids, finding.ids)));
+    return ok(
+      `Asked again${where(live)}: ${held.length} question${held.length === 1 ? "" : "s"} of kind "${args.kind}" ${held.length === 1 ? "is" : "are"} no longer left${back.length ? ` — the wall asks ${back.length === 1 ? "it" : `${back.length} of them`} now: ${back.map((finding) => finding.text).join(" ")}` : " — and the wall no longer asks it; the question had already changed"}.`,
+      result,
+    );
+  },
+);
+
 server.registerTool(
   "move_scene",
   {
@@ -1278,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.` : "";
@@ -1403,7 +1555,7 @@ server.registerTool(
   "list_structures",
   {
     title: "List the structures",
-    description: "The structures apply_template can lay on a wall: the built-in ones, and the writer's own saved from their walls (save_structure), each with its beats.",
+    description: "The structures apply_template can lay on a wall: the built-in ones, and the writer's own saved from their walls (save_structure), each with its beats. compare_structure sets one beside this wall's beats without laying anything.",
     inputSchema: {},
   },
   async () => {
@@ -1413,11 +1565,43 @@ server.registerTool(
       `the writer's own: ${own.length}`,
       ...own.map((structure) => `  - ${structure.id} — "${structure.name}" (${structure.beats.length} beats: ${structure.beats.map((beat) => `${beat.name} at ${Math.round(beat.at * 100)}%`).join(", ")})`),
       `built in: ${TEMPLATES.length} — ${TEMPLATES.map((template) => `${template.id} "${template.name}" (${template.beats.length} beats)`).join(", ")}; each beat's name, prompt and place in the story are in the JSON`,
+      "compare_structure sets one of these beside this wall's beats, page by page, and lays nothing",
     ];
     return ok(lines.join("\n"), { builtIn: TEMPLATES.map((template) => ({ id: template.id, name: template.name, beats: template.beats })), own });
   },
 );
 
+server.registerTool(
+  "compare_structure",
+  {
+    title: "A structure beside the wall",
+    description:
+      "Set a structure beside this wall's beats without laying anything: each of the structure's beats with the page it falls near on this board's target, and the nearest of the wall's own beats within six pages — one to one, in order — with how far off it is (here, near, N pp early or late). A reading, like read_wall: nothing moves and no card is made. Takes a built-in structure by id (turns, three-acts, eight-sequences, fifteen-beats, story-circle) or one of the writer's own by name or id; turns is the default.",
+    inputSchema: { structure: z.string().optional() },
+  },
+  async (args) => {
+    const { state } = await readBoard();
+    const { project } = await readProject();
+    const wanted = (args.structure ?? "turns").trim().toLowerCase();
+    const own = project.structures ?? [];
+    const chosen =
+      TEMPLATES.find((template) => template.id === wanted || template.name.toLowerCase() === wanted) ??
+      own.find((structure) => structure.id === wanted || structure.name.toLowerCase() === wanted);
+    if (!chosen) return ok(`No structure called "${args.structure}". list_structures names the built-in five and the writer's own.`);
+    const comparison = compareStructure(state, chosen.beats);
+    const beats = state.notes.filter((note) => note.rank === "beat").length;
+    const lines = [
+      `"${chosen.name}" beside this wall's ${beats} beat${beats === 1 ? "" : "s"}, of ${formatPages(state.targetEighths)} pages (the story so far runs to p. ${comparison.soFar}); a match is the nearest of the wall's beats within ${MATCH_PAGES} pages, one to one and in order:`,
+      ...describeComparison(comparison).map((line) => `  - ${line}`),
+      comparison.unmatched.length
+        ? `beats of the wall no beat of the structure answers: ${comparison.unmatched.map((beat) => `"${beat.headline}" (p. ${beat.page})`).join(", ")}`
+        : "every beat of the wall answers one of the structure's",
+      beats === 0 ? "No card on this board is marked as a beat (set_rank), so there is nothing to compare; apply_template lays the structure's beats to fill." : "Nothing moved and nothing was made: this is a reading. apply_template lays the beats as cards when the writer wants them.",
+    ];
+    return ok(lines.join("\n"), { structure: { id: chosen.id, name: chosen.name }, ...comparison });
+  },
+);
+
 server.registerTool(
   "save_structure",
   {
@@ -1481,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",
   {
@@ -1550,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(
@@ -1647,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);
@@ -1916,7 +2155,7 @@ server.registerTool(
     trail.pop();
     undone.push(last);
     const { boardId } = await readBoard();
-    const live = await writeBoard(last.before, rev, base, boardId);
+    const live = await writeBoard(last.before, rev, base, boardId, "exact");
     const orderLine = /^(move_scene|organize)/.test(last.what) ? ` Story order now: ${readingOrder(last.before.notes).map((note, index) => `${index + 1}. ${note.headline}`).join(", ")}.` : "";
     const cardsDiff = last.before.notes.length - state.notes.length;
     const countLine = cardsDiff > 0 ? ` ${cardsDiff} card(s) back.` : cardsDiff < 0 ? ` ${-cardsDiff} card(s) gone.` : "";
@@ -1942,7 +2181,7 @@ server.registerTool(
     }
     undone.pop();
     const after = normalizeState(JSON.parse(last.after));
-    const live = await writeBoard(after, rev, base, boardId);
+    const live = await writeBoard(after, rev, base, boardId, "exact");
     trail.push(last);
     return ok(`Redid ${last.what}${where(live)}. ${undone.length} more can be redone. list_board has the board.`, { redid: last.what, notes: after.notes.length, arrows: after.arrows.length, groups: after.groups.length });
   },
@@ -1961,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(
@@ -2012,7 +2252,7 @@ server.registerTool(
   {
     title: "Add character",
     description:
-      "Add a person to the board's cast — the roster every card casts from. One record per person: the same name twice is refused and the existing record returned. Add someone here before casting them on a card.",
+      "Add a person to the project's cast — one roster every board of the project casts from, so a person is one record across the pilot and the episodes after it. The same name twice is refused and the existing record returned. Add someone here before casting them on a card.",
     inputSchema: { name: z.string().min(1) },
   },
   async (args) => {
@@ -2022,7 +2262,7 @@ server.registerTool(
         ? ok(`Already in the cast as "${result.name}" (${result.id}). Use that id.`, result)
         : ok("No character added: the name was empty.");
     }
-    return ok(`Added "${result.name}" to the cast${where(live)}.`, result);
+    return ok(`Added "${result.name}" to the project's cast${where(live)}; every board of the project casts from it.`, result);
   },
 );
 
@@ -2161,13 +2401,23 @@ server.registerTool(
   {
     title: "Remove character",
     description:
-      "Remove a person from the cast by id. They leave every card they were on. The cards themselves stay.",
+      "Remove a person from the project's cast by id. They leave every card they were on here; the cards themselves stay. Refused while another board of the project has them on a card: take them off there first.",
     inputSchema: { id: z.string() },
   },
   async (args) => {
+    const { state, boardId } = await readBoard();
+    const person = state.characters.find((character) => character.id === args.id);
+    if (!person) return ok(`No character with id ${args.id}. Call list_board for the cast.`);
+    const { project, boards } = await readProject();
+    const elsewhere = castElsewhere(project, boards, boardId ?? project.activeBoardId)[args.id] ?? [];
+    if (elsewhere.length) {
+      return ok(
+        `"${person.name}" stays: the cast is the project's, and a person leaves it only when no board has them on a card — they are on ${elsewhere.map((item) => `${item.cards} card${item.cards === 1 ? "" : "s"} of "${item.board}"`).join(" and ")}. open_board there and cast them off those cards first, or leave them.`,
+      );
+    }
     const { changed, live } = await commit({ type: "remove_character", id: args.id });
     if (!changed) return ok(`No character with id ${args.id}. Call list_board for the cast.`);
-    return ok(`Removed from the cast and from every card${where(live)}.`);
+    return ok(`Removed "${person.name}" from the project's cast and from every card${where(live)}.`);
   },
 );
 
@@ -2838,7 +3088,7 @@ server.registerTool(
     const fresh = { ...emptyState(), ...(target ? { targetEighths: target } : {}) };
     const { live } = await openBoardEverywhere(next, { ...boards, [board.id]: fresh }, rev, base, board.id);
     return ok(
-      `Added "${board.name}" (${board.id}) and opened it${where(live)}: every card call lands there now, and the writer's open wall switched with it; open_board "${project.boards.findIndex((item) => item.id === project.activeBoardId) + 1}" comes back. It is empty. The logline is the story's question when the writer has one — leave it empty rather than invent it — and the cards come next.${next.name === "Untitled project" ? " The project is still \"Untitled project\": rename_project names it." : ""}${next.boards.length === 2 && isSampleWall(isBoardState(boards[next.boards[0].id]) ? normalizeState(boards[next.boards[0].id]) : emptyState()) ? " The sample stays as Board 1; delete_board drops it." : ""}`,
+      `Added "${board.name}" (${board.id}) and opened it${where(live)}: every card call lands there now, and the writer's open wall switched with it; open_board "${project.boards.findIndex((item) => item.id === project.activeBoardId) + 1}" comes back. It is empty, and the project's cast is already there to cast from. The logline is the story's question when the writer has one — leave it empty rather than invent it — and the cards come next.${next.name === "Untitled project" ? " The project is still \"Untitled project\": rename_project names it." : ""}${next.boards.length === 2 && isSampleWall(isBoardState(boards[next.boards[0].id]) ? normalizeState(boards[next.boards[0].id]) : emptyState()) ? " The sample stays as Board 1; delete_board drops it." : ""}`,
       board,
     );
   },