plotcoder-board 0.1.0

package/src/board/reminders.d.ts

@@ -0,0 +1,6 @@
+// Type surface for reminders.js.
+
+import type { Reminder } from "../reminderStore";
+
+export declare const DEFAULT_REMINDERS: Reminder[];
+export declare function titleFromBody(body: string): string;

package/src/board/reminders.js

@@ -0,0 +1,53 @@
+// The built-in reminders (R10) and the title rule (R11), DOM-free so the
+// MCP server can list and add reminders through the bridge (R17 backlog).
+
+export const DEFAULT_REMINDERS = [
+  {
+    id: "story-is-change",
+    title: "Story is change",
+    body: "A scene earns its place when someone wants something, meets resistance, and leaves in a different position than they entered. If nothing shifts — information, power, emotion, or the plan — the scene is usually decoration.",
+    builtIn: true,
+    createdAt: "2026-09-12T00:00:00.000Z",
+  },
+  {
+    id: "character-under-pressure",
+    title: "Character is revealed under pressure",
+    body: "Personality on the page is not description; it’s what a person does when the easy option is gone. Give them a clear want, a stronger need they may not admit, and a flaw that makes the want costly.",
+    builtIn: true,
+    createdAt: "2026-09-12T00:00:00.000Z",
+  },
+  {
+    id: "structure-is-a-map",
+    title: "Structure is a delivery system, not a religion",
+    body: "Three acts, sequences, and beats are useful because audiences need orientation: a world, a disruption, rising stakes, a point of no return, and a confrontation that answers the story’s question. Use the map; don’t let the map write the movie.",
+    builtIn: true,
+    createdAt: "2026-09-12T00:00:00.000Z",
+  },
+  {
+    id: "dialogue-does-two-jobs",
+    title: "Dialogue should do more than one job",
+    body: "The best lines reveal character, advance plot, and hide subtext at the same time. People rarely say exactly what they mean. Cut anything a character would not say in that moment to that person.",
+    builtIn: true,
+    createdAt: "2026-09-12T00:00:00.000Z",
+  },
+  {
+    id: "write-for-the-camera",
+    title: "Write for the camera and the cut",
+    body: "Prefer action, image, and behavior over explanation. White space matters. If a reader has to work to see the movie, the movie is not on the page yet.",
+    builtIn: true,
+    createdAt: "2026-09-12T00:00:00.000Z",
+  },
+  {
+    id: "readability-is-craft",
+    title: "Readability is a craft skill",
+    body: "Industry readers skim. Short paragraphs, precise sluglines, and verbs that carry the shot will get you further than clever formatting.",
+    builtIn: true,
+    createdAt: "2026-09-12T00:00:00.000Z",
+  },
+];
+
+
+export function titleFromBody(body) {
+  const first = body.trim().split(/(?<=[.!?])\s+/)[0] ?? "";
+  return first.replace(/[.!?]$/, "").slice(0, 80);
+}

package/src/board/sync.d.ts

@@ -0,0 +1,65 @@
+// Type surface for sync.js — the sync decisions (R4).
+
+import type { BoardMeta, ProjectRecord } from "./project";
+
+export declare function conflictName(name: string, device: string, when: Date): string;
+
+export type SignInPlan = {
+  /** The project this device should adopt, or null to keep its own. */
+  adopt: ProjectRecord | null;
+  /** The project record to push, or null. */
+  pushProject: ProjectRecord | null;
+  /** Board ids whose state this device should push. */
+  pushBoards: string[];
+  /** Boards carried over and renamed so it is plain where they came from. */
+  renamed: string[];
+};
+
+export declare function reconcileOnSignIn(input: {
+  local: { project: ProjectRecord };
+  remote: { project: ProjectRecord | null };
+  isSeed: boolean;
+  device: string;
+  now: Date;
+}): SignInPlan;
+
+export declare function mergeProjects(
+  remote: ProjectRecord,
+  local: ProjectRecord,
+  now: Date,
+  carry?: (board: BoardMeta) => BoardMeta,
+): ProjectRecord;
+
+export declare function resolveBoardConflict(input: {
+  project: ProjectRecord;
+  boardId: string;
+  device: string;
+  now: Date;
+}): { project: ProjectRecord; copy: BoardMeta } | null;
+
+export declare function deviceName(userAgent: string | undefined): string;
+
+export type PushOutcome = "insert" | "update" | "conflict";
+export declare function pushOutcome(input: { remoteRev: number | null | undefined; seenRev: number }): PushOutcome;
+
+export type OpenOutcome = "nothing" | "push" | "adopt" | "conflict";
+export declare function openOutcome(input: {
+  remoteRev: number | null | undefined;
+  seenRev: number;
+  dirty: boolean;
+}): OpenOutcome;
+
+export declare function planSignIn(input: {
+  isSeed: boolean;
+  localProjectId: string;
+  remoteProjectIds: string[];
+}): { pushLocalAsNew: boolean; open: string | null; pick: boolean };
+
+export declare function liveOutcome(input: {
+  remoteRev: number;
+  seenRev: number;
+  dirty: boolean;
+}): "nothing" | "adopt" | "conflict";
+
+/** What a landed reset link's fragment says: nothing, or a stale link, or another error. */
+export declare function linkOutcome(hash: string | null | undefined): { kind: "stale" | "error"; message: string } | null;

package/src/board/sync.js

@@ -0,0 +1,198 @@
+// Sync decisions (R4, roadmap item 2).
+//
+// The rules that decide what a device does when it meets the account, and
+// what a push does when it finds the account ahead. Pure and DOM-free so they
+// are tested like the kernel; the network is a thin layer in syncStore.ts.
+//
+// The one rule that matters: nothing is ever lost, and there is no merge
+// dialog. When two copies disagree, the account's copy stays the board, and
+// this device's copy becomes a new board of the project, named for where it
+// came from and when, so the writer merges by hand with the tools they have.
+
+/** "Episode 2 · from this laptop, 3:14 pm" */
+export function conflictName(name, device, when) {
+  const time = when.toLocaleTimeString(undefined, { hour: "numeric", minute: "2-digit" });
+  return `${name} · from ${device}, ${time}`;
+}
+
+/**
+ * First meeting between a device and the account.
+ *
+ * - The account has nothing: push everything; this device seeds it.
+ * - The account has a project and this device has never synced: the account's
+ *   project becomes this device's project. Boards on this device that the
+ *   account does not have are carried over as new boards, renamed so it is
+ *   plain where they came from — unless this device holds only the untouched
+ *   seed wall, which is not work and is dropped.
+ *
+ * Returns what to adopt locally and what to push.
+ */
+export function reconcileOnSignIn({ local, remote, isSeed, device, now }) {
+  if (!remote.project) {
+    return {
+      adopt: null,
+      pushProject: local.project,
+      pushBoards: local.project.boards.map((board) => board.id),
+      renamed: [],
+    };
+  }
+  const remoteIds = new Set(remote.project.boards.map((board) => board.id));
+  const carried = local.project.boards.filter((board) => !remoteIds.has(board.id));
+  if (isSeed || carried.length === 0) {
+    return { adopt: remote.project, pushProject: null, pushBoards: [], renamed: [] };
+  }
+  const merged = mergeProjects(remote.project, local.project, now, (board) => ({
+    ...board,
+    name: conflictName(board.name, device, now),
+  }));
+  return {
+    adopt: merged,
+    pushProject: merged,
+    pushBoards: carried.map((board) => board.id),
+    renamed: carried.map((board) => board.id),
+  };
+}
+
+/**
+ * The account's record, plus every board this device has that the account
+ * does not. The account's name, premise and order win; the device's boards
+ * go after them, through `carry` (identity by default) so a caller can rename
+ * them. The open board stays this device's if the merged project has it.
+ */
+export function mergeProjects(remote, local, now, carry = (board) => board) {
+  const remoteIds = new Set(remote.boards.map((board) => board.id));
+  const carried = local.boards
+    .filter((board) => !remoteIds.has(board.id))
+    .map((board) => ({ ...carry(board), updatedAt: now.toISOString() }));
+  if (carried.length === 0 && remote.boards.some((board) => board.id === local.activeBoardId) === false) {
+    return remote;
+  }
+  const boards = [...remote.boards, ...carried];
+  const activeBoardId = boards.some((board) => board.id === local.activeBoardId)
+    ? local.activeBoardId
+    : remote.activeBoardId;
+  if (carried.length === 0 && activeBoardId === remote.activeBoardId) return remote;
+  return { ...remote, boards, activeBoardId, updatedAt: now.toISOString() };
+}
+
+/**
+ * A push found the account ahead of what this device last saw. Keep the
+ * account's board; this device's version becomes a new board.
+ */
+export function resolveBoardConflict({ project, boardId, device, now }) {
+  const board = project.boards.find((item) => item.id === boardId);
+  if (!board) return null;
+  const copy = {
+    id: `${boardId}-${Date.now().toString(36)}`,
+    name: conflictName(board.name, device, now),
+    createdAt: now.toISOString(),
+    updatedAt: now.toISOString(),
+  };
+  const index = project.boards.findIndex((item) => item.id === boardId);
+  const boards = [...project.boards];
+  boards.splice(index + 1, 0, copy);
+  return { project: { ...project, boards, updatedAt: now.toISOString() }, copy };
+}
+
+/** A short name for this device from the browser, without asking. */
+export function deviceName(userAgent) {
+  const ua = userAgent ?? "";
+  if (/iPhone/.test(ua)) return "an iPhone";
+  if (/iPad/.test(ua)) return "an iPad";
+  if (/Android/.test(ua)) return "an Android phone";
+  if (/Mac OS X/.test(ua)) return "a Mac";
+  if (/Windows/.test(ua)) return "a Windows PC";
+  if (/Linux/.test(ua)) return "a Linux machine";
+  return "another device";
+}
+
+/**
+ * What a push should do, given what the account says about the row.
+ *
+ * - The row is missing: insert it.
+ * - The row is at the revision this device last saw: update it.
+ * - The row is ahead: conflict — the caller keeps the account's copy and
+ *   turns this device's into a new board.
+ */
+export function pushOutcome({ remoteRev, seenRev }) {
+  if (remoteRev === null || remoteRev === undefined) return "insert";
+  if (remoteRev === seenRev) return "update";
+  return "conflict";
+}
+
+/**
+ * What opening the app should do with a board the account holds, given what
+ * this device last saw of it and whether this device has changes it has not
+ * pushed yet.
+ *
+ * - Not ahead of what we saw: nothing to pull; push if dirty.
+ * - Ahead and this device is clean: adopt the account's copy.
+ * - Ahead and this device is dirty: conflict, resolved like a push.
+ */
+export function openOutcome({ remoteRev, seenRev, dirty }) {
+  if (remoteRev === null || remoteRev === undefined) return dirty ? "push" : "nothing";
+  if (remoteRev <= seenRev) return dirty ? "push" : "nothing";
+  return dirty ? "conflict" : "adopt";
+}
+
+/**
+ * Meeting an account that can hold many projects (R40).
+ *
+ * - The account has none: this device's project becomes its first.
+ * - This device holds only the untouched seed wall: nothing to carry; open
+ *   the account's one project, or ask which when there are several.
+ * - This device holds work: it becomes a new project of the account, kept
+ *   whole, and the writer picks between it and the rest.
+ *
+ * Returns whether to push the local project as a new one, which project to
+ * open now (null when the writer should pick), and whether to show the picker.
+ */
+export function planSignIn({ isSeed, localProjectId, remoteProjectIds }) {
+  if (remoteProjectIds.length === 0) {
+    return { pushLocalAsNew: true, open: localProjectId, pick: false };
+  }
+  if (isSeed) {
+    return remoteProjectIds.length === 1
+      ? { pushLocalAsNew: false, open: remoteProjectIds[0], pick: false }
+      : { pushLocalAsNew: false, open: null, pick: true };
+  }
+  if (remoteProjectIds.includes(localProjectId)) {
+    return { pushLocalAsNew: false, open: localProjectId, pick: remoteProjectIds.length > 1 };
+  }
+  return { pushLocalAsNew: true, open: localProjectId, pick: true };
+}
+
+/**
+ * A change to a board arrived live from another person (R41). Take it when
+ * it is ahead of what this device saw and this device has nothing unpushed on
+ * that board; otherwise let the next push settle it as a conflict.
+ */
+export function liveOutcome({ remoteRev, seenRev, dirty }) {
+  if (remoteRev <= seenRev) return "nothing";
+  return dirty ? "conflict" : "adopt";
+}
+
+// --- The reset link (R39): what the address says when it lands ------------
+//
+// A reset link that still works signs the writer in; the client reads that
+// from the address itself and says PASSWORD_RECOVERY. One that has expired
+// or was already used comes back with the reason in the fragment instead:
+// #error=access_denied&error_code=otp_expired&error_description=... . Pure,
+// so it is testable; the store clears the fragment after reading it.
+
+/**
+ * Read a landed link's fragment. Returns null when it says nothing, or
+ * { kind: "stale" | "error", message } for the writer.
+ */
+export function linkOutcome(hash) {
+  const raw = (hash ?? "").replace(/^#/, "");
+  if (!raw) return null;
+  const params = new URLSearchParams(raw);
+  const code = params.get("error_code") ?? "";
+  const description = params.get("error_description") ?? "";
+  if (!params.get("error") && !code && !description) return null;
+  if (code === "otp_expired" || /expired|invalid/i.test(description)) {
+    return { kind: "stale", message: "That reset link has expired or was already used. Ask for another below — they last an hour and work once." };
+  }
+  return { kind: "error", message: description || "That link did not work. Ask for another below." };
+}

package/src/board/templates.d.ts

@@ -0,0 +1,21 @@
+// Type surface for templates.js — structure templates (R38).
+
+export type TemplateBeat = {
+  name: string;
+  /** The question the beat exists to answer; goes on the change line. */
+  prompt: string;
+  /** Where it tends to fall, as a fraction of the story, 0 to 1. */
+  at: number;
+};
+
+export type StructureTemplate = {
+  id: string;
+  name: string;
+  blurb: string;
+  beats: TemplateBeat[];
+};
+
+export declare const TEMPLATES: readonly StructureTemplate[];
+export declare function templateById(id: string): StructureTemplate | null;
+/** The page a beat tends to fall near, on a story of this many eighths. */
+export declare function beatPage(at: number, targetEighths: number): number;

package/src/board/templates.js

@@ -0,0 +1,110 @@
+// Structure templates (R38, closing open question 7).
+//
+// A template is a list of named beats, each with a prompt for its change line
+// and the fraction of the story it tends to fall near. Applying one creates
+// beat cards and nothing else: no mode, no lock, no field on the card that
+// remembers which template it came from. The house method (R18) is the
+// first and the default. Names are plain words where a book's are its own.
+//
+// Pure data and DOM-free, like the kernel, so the wall, window.plotcoder and
+// the MCP server all read the same five.
+
+/** A beat of a template. `at` is a fraction of the story, 0 to 1. */
+function beat(name, prompt, at) {
+  return { name, prompt, at };
+}
+
+export const TEMPLATES = [
+  {
+    id: "turns",
+    name: "Turns",
+    blurb: "The house method: named major turns, eight to fifteen.",
+    beats: [
+      beat("Opening image", "What does the world look like before anything happens?", 0.01),
+      beat("The inciting incident", "What breaks the routine and cannot be ignored?", 0.1),
+      beat("The decision", "What do they choose to do about it, and what does it cost to choose?", 0.2),
+      beat("Into the middle", "What door closes behind them?", 0.25),
+      beat("The midpoint", "What turns here so there is no going back?", 0.5),
+      beat("The complication", "What makes the plan worse than no plan?", 0.62),
+      beat("The lowest point", "What is lost, and who is to blame?", 0.75),
+      beat("The climax", "What answers the central question, and how much does it cost?", 0.9),
+      beat("Closing image", "What does the world look like after?", 0.98),
+    ],
+  },
+  {
+    id: "three-acts",
+    name: "Three acts",
+    blurb: "The oldest map: beats as act breaks.",
+    beats: [
+      beat("Setup", "Who is this, and what do they want before the story starts?", 0.01),
+      beat("The inciting incident", "What breaks the routine and cannot be ignored?", 0.1),
+      beat("Into act two", "What choice ends the world of act one?", 0.25),
+      beat("The midpoint", "What turns here so there is no going back?", 0.5),
+      beat("Into act three", "What is the last decision that makes the ending necessary?", 0.75),
+      beat("The climax", "What answers the central question, and how much does it cost?", 0.9),
+      beat("Resolution", "What is different now, and who knows it?", 0.97),
+    ],
+  },
+  {
+    id: "eight-sequences",
+    name: "Eight sequences",
+    blurb: "One beat opening each sequence, an eighth of the story apart.",
+    beats: [
+      beat("Sequence one: the world", "What is the status quo, and what disturbs it?", 0.0),
+      beat("Sequence two: the problem", "What is the predicament, and what is chosen?", 0.125),
+      beat("Sequence three: the first try", "What is the first attempt, and why does it fail?", 0.25),
+      beat("Sequence four: the raised stakes", "What is tried next, and what does it cost?", 0.375),
+      beat("Sequence five: the reversal", "What turns at the midpoint?", 0.5),
+      beat("Sequence six: the collapse", "What falls apart?", 0.625),
+      beat("Sequence seven: the last push", "What is the final plan?", 0.75),
+      beat("Sequence eight: the resolution", "What is answered, and what is left?", 0.875),
+    ],
+  },
+  {
+    id: "fifteen-beats",
+    name: "Fifteen beats",
+    blurb: "The popular beat sheet, in plain words.",
+    beats: [
+      beat("Opening image", "What does the world look like before?", 0.01),
+      beat("The theme is said aloud", "Who says, in passing, what the story is about?", 0.05),
+      beat("The world before", "What is the routine, and what is wrong with it?", 0.06),
+      beat("The catalyst", "What arrives and changes everything?", 0.1),
+      beat("The debate", "Why not go? What is the fear?", 0.15),
+      beat("Into the new world", "What is the choice that starts act two?", 0.25),
+      beat("The second story", "Who arrives to carry the theme?", 0.28),
+      beat("The promise of the premise", "What is the fun the poster promised?", 0.35),
+      beat("The midpoint", "A false victory or a false defeat: which, and what is raised?", 0.5),
+      beat("The opposition closes in", "What goes wrong from outside, and what from inside?", 0.6),
+      beat("All is lost", "What dies, in fact or in feeling?", 0.75),
+      beat("The dark night", "What is understood in the dark?", 0.8),
+      beat("Into the finale", "What is the new idea that makes act three possible?", 0.85),
+      beat("The finale", "How is the lesson applied and the opposition beaten?", 0.9),
+      beat("Final image", "What does the world look like after?", 0.99),
+    ],
+  },
+  {
+    id: "story-circle",
+    name: "Story circle",
+    blurb: "The journey as a circle, in eight steps.",
+    beats: [
+      beat("Comfort", "Where are they at ease, and what is missing?", 0.0),
+      beat("Need", "What do they want badly enough to move?", 0.125),
+      beat("Crossing", "What unfamiliar place do they enter?", 0.25),
+      beat("Adapting", "What do they learn the hard way?", 0.375),
+      beat("Finding", "What do they get that they wanted?", 0.5),
+      beat("Paying", "What does it cost them?", 0.625),
+      beat("Returning", "How do they come back to where they started?", 0.75),
+      beat("Changed", "What is different about them now?", 0.875),
+    ],
+  },
+];
+
+export function templateById(id) {
+  return TEMPLATES.find((template) => template.id === id) ?? null;
+}
+
+/** The page a beat tends to fall near, on a story of this many eighths. */
+export function beatPage(at, targetEighths) {
+  const pages = Math.max(1, Math.round(targetEighths / 8));
+  return Math.min(pages, Math.max(1, Math.round(at * pages) + (at === 0 ? 1 : 0)));
+}

package/src/board/words.d.ts

@@ -0,0 +1,10 @@
+// Type surface for words.js — what these words mean (R42).
+
+export type WordTarget = "card" | "logline" | "beat" | "change" | "corner" | "arrow" | "length" | "cast" | "place" | "group" | "strip";
+export type Word = { id: string; name: string; sentence: string; target?: WordTarget };
+export type WordGroup = { id: string; name: string; words: Word[] };
+
+export declare const WORD_GROUPS: WordGroup[];
+export declare const WORDS: Word[];
+export declare function wordSentence(id: string): string;
+export declare function wordsAsText(): string;

package/src/board/words.js

@@ -0,0 +1,201 @@
+// What these words mean (R42).
+//
+// PlotCoder talks like a story room: beat, logline, change line, the folded
+// corner, eighths. This is the one place that says what each means — one
+// sentence, PlotCoder's meaning, for a person who has not sat in that room.
+// Grouped in the method's order (R18), which is the order a new person meets
+// them. DOM-free and shared: the Words sheet, the one-second hovers on the
+// wall, the skill and the MCP tool descriptions all read from here, so the
+// app never explains a word two ways.
+//
+// `target` names the thing on the wall a definition can light up ("show me");
+// words that are not things have none.
+
+export const WORD_GROUPS = [
+  {
+    id: "first",
+    name: "First",
+    words: [
+      {
+        id: "wall",
+        name: "The wall",
+        sentence: "The corkboard. It is bigger than the window: drag to move around it, pinch or the magnifier to zoom.",
+      },
+      {
+        id: "card",
+        name: "A card",
+        sentence: "One scene of the movie: one place, one stretch of time. A headline on top, and under it the change line: what is different after the scene than before. A new place or a new time is a new card.",
+        target: "card",
+      },
+      {
+        id: "logline",
+        name: "The logline",
+        sentence: "The one question the whole story argues, at the top of the wall. “Can Maya forgive?”",
+        target: "logline",
+      },
+      {
+        id: "premise",
+        name: "The premise",
+        sentence: "Above the logline when a project has several boards: the line the whole series is about.",
+      },
+      {
+        id: "beat",
+        name: "A beat",
+        sentence:
+          "One of the eight to fifteen big turns — the moment it starts, the point of no return, the lowest point, the climax. A whole card, the scene where the turn happens, marked as a beat; marking it never moves it. Everything else is a scene.",
+        target: "beat",
+      },
+      {
+        id: "scene",
+        name: "A scene",
+        sentence: "Every card that is not a beat: what happens between the turns. One card, one scene.",
+        target: "card",
+      },
+    ],
+  },
+  {
+    id: "card",
+    name: "On a card",
+    words: [
+      {
+        id: "change",
+        name: "The change line",
+        sentence: "The second line. If nothing is different after the scene, the scene is usually decoration.",
+        target: "change",
+      },
+      {
+        id: "corner",
+        name: "The folded corner",
+        sentence:
+          "This card plants something — a gun on the wall — that must pay off later. The card says unpaid, and the bar’s Asks line keeps asking, until a setup arrow leaves it. One thing, three words: the corner is folded, the tool’s flag is plants, the wall’s question is unpaid.",
+        target: "corner",
+      },
+      {
+        id: "arrow",
+        name: "An arrow",
+        sentence: "Follows: this comes after that. Setup: this plants what that pays off. Drag a card’s handle onto another.",
+        target: "arrow",
+      },
+      {
+        id: "length",
+        name: "Length",
+        sentence:
+          "How long the scene runs, in eighths of a script page, the industry’s unit; the tools take pages, and a fraction is fine. Written scenes measure themselves; the rest is your guess.",
+        target: "length",
+      },
+      {
+        id: "cast",
+        name: "The cast on a card",
+        sentence: "Who is in the scene. Each person has a page: looks, voice, wants, needs.",
+        target: "cast",
+      },
+      {
+        id: "place",
+        name: "The place",
+        sentence: "Where it happens, in your own words. Hold a place and its scenes light up.",
+        target: "place",
+      },
+    ],
+  },
+  {
+    id: "around",
+    name: "Around the wall",
+    words: [
+      { id: "group", name: "Group", sentence: "A frame around cards you select, with a title. It moves as one. A treatment’s acts can be groups, titled Act one, Act two.", target: "group" },
+      {
+        id: "paper",
+        name: "Paper",
+        sentence: "The colour of a card. It means nothing to the app; use it as the writer does — an act, a thread, a mood.",
+      },
+      { id: "organize", name: "Organize", sentence: "Lays the cards out in rows along their arrows. One undo step." },
+      {
+        id: "structure",
+        name: "A structure",
+        sentence:
+          "A list of named beats laid on the wall as beat cards to fill in — Turns (the house method), Three acts, and others. Afterwards there are only cards; nothing remembers which structure it was.",
+      },
+      {
+        id: "acts",
+        name: "Acts",
+        sentence:
+          "PlotCoder has no acts of its own. The wall reads left to right, and a structure’s beats are the act breaks. A colour or a group can mark an act if the writer wants one.",
+      },
+      {
+        id: "wordmark",
+        name: "The wordmark",
+        sentence: "The PlotCoder mark at the top left. It is the door to you and your projects: sign in, share, switch.",
+      },
+      {
+        id: "lens",
+        name: "The Cast panel",
+        sentence: "Cast, at the top right: the roster, each person’s page, and the places. Hold a name or a place and its scenes light up.",
+      },
+      {
+        id: "strip",
+        name: "Read the story",
+        sentence: "The strip along the bottom: every card by length, the beats marked. Move along it to read the story in order.",
+        target: "strip",
+      },
+      {
+        id: "runtime",
+        name: "Runtime and target",
+        sentence: "What the cards add up to, against the length you are aiming at: 120 pages is a feature, 60 an hour, 30 a half. A page runs about a minute on screen.",
+      },
+      {
+        id: "reminders",
+        name: "Reminders",
+        sentence: "Your own principles, kept where you and an agent read them before touching the wall.",
+      },
+    ],
+  },
+  {
+    id: "pages",
+    name: "Pages",
+    words: [
+      {
+        id: "pages",
+        name: "Pages",
+        sentence: "The wall as a script: the scenes’ text in order, set as a screenplay, with page numbers. Type there and it lands on the card.",
+      },
+      {
+        id: "formats",
+        name: "Fountain and Final Draft",
+        sentence: "Two ways out and in. Fountain is plain text any tool reads; Final Draft is the program most productions use.",
+      },
+      {
+        id: "revisions",
+        name: "Locked numbers, revisions",
+        sentence: "Once a draft goes out, scene numbers stop moving and changes print in a colour; a scene added after the lock keeps its own letter, 2A after 2. For after the writing.",
+      },
+    ],
+  },
+  {
+    id: "horizon",
+    name: "The horizon",
+    words: [
+      {
+        id: "take",
+        name: "A brief, a take",
+        sentence:
+          "A brief is everything the wall knows about a scene, written for a tool that makes video. A take is what came back, filed on the card.",
+      },
+      {
+        id: "agent",
+        name: "An agent",
+        sentence: "A program you direct, which has every tool a person here has. It calls them; it never fakes a mouse.",
+      },
+    ],
+  },
+];
+
+export const WORDS = WORD_GROUPS.flatMap((group) => group.words);
+
+/** One word's sentence, by id; empty when there is no such word. */
+export function wordSentence(id) {
+  return WORDS.find((word) => word.id === id)?.sentence ?? "";
+}
+
+/** The words as one block of text, for the skill and an agent's reading. */
+export function wordsAsText() {
+  return WORD_GROUPS.map((group) => [group.name, ...group.words.map((word) => `  ${word.name}: ${word.sentence}`)].join("\n")).join("\n\n");
+}