plotcoder-board 0.1.34 → 0.1.36

package/README.md

@@ -4,6 +4,8 @@ A storylining app for screenwriters, live at [plotcoder.com](http://plotcoder.co
 
 PlotCoder is a set of tools for building a storyline, covering the activities a writer does today in Final Draft. It is designed so that an **agent driven by a person** has every one of those tools: the person directs, the agent operates, and the board on screen is the person's window onto the same records. The first tool is the wall, a digital corkboard for breaking and rearranging plot before writing the script, because that is the part of the job Final Draft does worst. Pages come last. Once the tools exist, workflows get launched on top of them. The horizon, a long way off: a person makes a storyline they believe in, then the app helps them drive agents that build segments of the movie with video generation tools.
 
+**Using it as a writer:** [plotcoder.com/writers.html](https://plotcoder.com/writers.html) says how, from the door to the script out, the agent first. Its source is `public/writers.html`, and a change to a gesture or a sheet changes it in the same pull request (R63).
+
 The full statement of purpose, every decision, and every requirement lives in [REQUIREMENTS.md](REQUIREMENTS.md). Read it before changing anything. It is the source of truth; this file is the front door.
 
 ## The method the tools serve
@@ -105,4 +107,4 @@ next round into a test of `claim_account` instead of the door it meant to test.
 
 ## Status
 
-Version 0.1.34. 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.
+Version 0.1.36. 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.34",
+  "version": "0.1.36",
   "type": "module",
   "scripts": {
     "dev": "vite",

package/scripts/plotcoder-mcp-server.mjs

@@ -71,6 +71,7 @@ import {
   setPremise,
   setPremiseOpen,
   setBoardNameOpen,
+  setProjectNameOpen,
   structureBeats,
   reidentifyProject,
   renameProject,
@@ -1065,7 +1066,7 @@ function summarize(state) {
       const pays = paidByHere.filter((item) => item.id === note.id).map((item) => `, pays off "${item.fromHeadline}" from "${item.fromBoardName}" (${episodeLabel(lastHeld.project, lastHeld.boards, item.fromBoardId, item.fromNoteId)})`).join("");
       const snap = state.revision?.snapshot?.[note.id];
       const revised = snap && (snap.headline !== note.headline || snap.change !== note.change || (snap.text ?? "") !== (note.text ?? "") || (snap.location ?? "") !== (note.location ?? "")) ? `, changed in ${state.revision.color}` : "";
-      const place = note.location ? `, at: ${note.location}` : "";
+      const place = note.location ? `, at: ${note.location}` : note.locationOpen ? `, at: open, by the writer's word — "${note.locationOpen}"` : "";
       const when = note.when ? `, when: ${note.when}` : note.whenOpen ? `, when: open, by the writer's word — "${note.whenOpen}"` : "";
       const openWord = note.open ? `, open (the writer's words): "${note.open}"` : "";
       const count = formatPages(noteEighths(note));
@@ -1576,9 +1577,11 @@ server.registerTool(
     const beatEighths = reading.beats.reduce((sum, beat) => sum + noteEighths(state.notes.find((note) => note.id === beat.id) ?? {}), 0);
     // Fields left open by the writer's word (R61): the logline and the whens are the reading's; the premise and the board's name are the project's.
     const openFieldLines = [
+      ...(projectForRead.nameOpen ? [`  - the project's name — ${projectForRead.nameOpen}`] : []),
       ...reading.openFields.filter((field) => field.field === "logline").map((field) => `  - the logline — ${field.words}`),
       ...(projectForRead.premiseOpen ? [`  - the premise — ${projectForRead.premiseOpen}`] : []),
       ...(readBoardMeta?.nameOpen ? [`  - this board's name — ${readBoardMeta.nameOpen}`] : []),
+      ...reading.openFields.filter((field) => field.field === "location").map((field) => `  - "${state.notes.find((note) => note.id === field.id)?.headline ?? field.id}" — where: ${field.words}`),
       // Whens left open in the same words are one line, not one per card (round twenty, entry 22).
       ...(() => {
         const byWords = new Map();
@@ -1599,6 +1602,7 @@ server.registerTool(
       `PlotCoder wall (${door(live, base)})`,
       ...(state.lock ? [`numbers: locked since ${String(state.lock.at).slice(0, 10)}; read_pages shows each scene's number`] : []),
       `board: "${readBoardMeta?.name ?? "?"}"${readBoardMeta?.nameOpen ? ` — its name is open, by the writer's word: "${readBoardMeta.nameOpen}"` : ""}${projectForRead.boards.length > 1 ? ` — board ${projectForRead.boards.findIndex((meta) => meta.id === readBoardMeta?.id) + 1} of ${projectForRead.boards.length} in the project "${projectForRead.name}"; open_board reads another` : ""}`,
+      ...(projectForRead.nameOpen ? [`project: "${projectForRead.name}" — its name is open, by the writer's word: "${projectForRead.nameOpen}"`] : []),
       ...(projectForRead.premiseOpen ? [`premise: open, by the writer's word — "${projectForRead.premiseOpen}"`] : []),
       `logline: ${state.loglineOpen ? `open, by the writer's word — "${state.loglineOpen}"` : state.logline ? `"${state.logline}"` : "(none yet)"}`,
       "the cast and the places are list_board's, not the reading's",
@@ -3010,7 +3014,7 @@ server.registerTool(
     });
     const total = parts.reduce((sum, part) => sum + part.on.length, 0);
     // An open card reads as open on a person's page too (round eighteen, entry 53).
-    const where_ = (note) => [note.location ? `at ${note.location}` : "", note.when ? note.when : note.whenOpen ? `when open: "${note.whenOpen}"` : "", note.rank === "beat" ? "beat" : "", note.open ? `open: "${note.open}"` : ""].filter(Boolean).join(" · ");
+    const where_ = (note) => [note.location ? `at ${note.location}` : note.locationOpen ? `where open: "${note.locationOpen}"` : "", note.when ? note.when : note.whenOpen ? `when open: "${note.whenOpen}"` : "", note.rank === "beat" ? "beat" : "", note.open ? `open: "${note.open}"` : ""].filter(Boolean).join(" · ");
     // A read opens with the door it came through, like every reading (round sixteen, entry 28); one scene a line (29).
     const lines = [
       `PlotCoder cast (${door(live, base)})`,
@@ -3087,14 +3091,16 @@ server.registerTool(
   {
     title: "Set where scenes happen",
     description:
-      "Set the place of one or more cards: where the scene happens, as the writer would say it ('the piano shop', 'the flat, kitchen') — a phrase, not a slugline. The same phrase on several cards is one place in the Cast panel; an empty string clears it. list_board shows each card's place as 'at: …'.",
-    inputSchema: { ids: z.array(z.string()).min(1), location: z.string() },
+      "Set the place of one or more cards: where the scene happens, as the writer would say it ('the piano shop', 'the flat, kitchen') — a phrase, not a slugline. The same phrase on several cards is one place in the Cast panel; an empty string clears it. Or leave the place open: pass open with the writer's words for why it is not decided — \"where it happens\" — and the reading lists it under open, by the writer's word, and stops asking where, while the card's other questions stand; a place decides it, open \"\" leaves it blank. list_board shows each card's place as 'at: …'.",
+    inputSchema: { ids: z.array(z.string()).min(1), location: z.string().optional(), open: z.string().optional() },
   },
   async (args) => {
+    if (args.location === undefined && args.open === undefined) return ok("Say which: location (the place, or \"\" to clear it), or open (the writer's words for why it is not decided).");
     const { state, changed, result, live } = await commit({
       type: "set_location",
       ids: args.ids,
-      location: args.location,
+      ...(args.location !== undefined ? { location: args.location } : {}),
+      ...(args.open !== undefined ? { open: args.open } : {}),
     });
     if (!changed) {
       const known = args.ids.filter((id) => state.notes.some((note) => note.id === id));
@@ -3102,6 +3108,10 @@ server.registerTool(
       return ok("No place changed: those cards already read that way.");
     }
     const place = result[0].location;
+    const placeOpen = result[0].locationOpen ?? "";
+    if (placeOpen) {
+      return ok(`${result.length} card(s) have their place left open, by the writer's word: "${placeOpen}"${where(live)}. The reading lists it and stops asking where; the heading prints the headline in its stead; set_location with a place decides it, open "" leaves it blank. The card is still asked about everything else.${stillOpen(result)}`, result);
+    }
     return ok(
       `${result.length} card(s) now ${place ? `at ${place}` : "nowhere"}${where(live)}.${nearPlaces(state, place)}${stillOpen(result)}`,
       result,
@@ -3507,7 +3517,7 @@ server.registerTool(
     const { project, boards, live, base, changedAt } = await readProject();
     return ok(
       [
-        `Project "${project.name}" (${door(live, base)})`,
+        `Project "${project.name}"${project.nameOpen ? ` — its name is open, by the writer's word: "${project.nameOpen}"` : ""} (${door(live, base)})`,
         `premise: ${project.premiseOpen ? `open, by the writer's word — "${project.premiseOpen}"` : project.premise ? `"${project.premise}"` : "(not set)"}`,
         `boards: ${project.boards.length}`,
         describeBoards(project, boards, changedAt),
@@ -3550,11 +3560,18 @@ server.registerTool(
   "rename_project",
   {
     title: "Rename the project",
-    description: "Rename the project — the name at the top of the wall, over every board.",
-    inputSchema: { name: z.string().min(1) },
+    description: "Rename the project — the name at the top of the wall, over every board. Or leave its name open: pass open with the writer's words for why the title is not decided — \"The Allotments, or Plot 14\" — and the name stands as it is while the reading lists the words; a name decides it, open \"\" takes the words back.",
+    inputSchema: { name: z.string().min(1).optional(), open: z.string().optional() },
   },
   async (args) => {
+    if (args.name === undefined && args.open === undefined) return ok("Say which: name, or open (the writer's words for why the title is not decided).");
     const { project, boards, rev, base, live } = await readProject();
+    if (args.name === undefined) {
+      const opened = setProjectNameOpen(project, args.open);
+      if (opened === project) return ok("Project name unchanged: it already reads that way.");
+      await writeProject(opened, boards, rev, base);
+      return ok(opened.nameOpen ? `The project keeps its name, "${opened.name}", and its name is left open, by the writer's word: "${opened.nameOpen}"${where(live)}. The reading lists it; rename_project with a name decides it.` : `The project's name, "${opened.name}", is no longer open${where(live)}.`, { name: opened.name, nameOpen: opened.nameOpen });
+    }
     const next = renameProject(project, args.name);
     if (next === project) return ok("Project name unchanged.");
     await writeProject(next, boards, rev, base);
@@ -3562,7 +3579,7 @@ server.registerTool(
     // follow the rename (round fifteen, entry 40).
     if (accountDoor) workingProject(next.id, next.name);
     const several = (next.boards ?? []).length > 1;
-    return ok(`Project renamed to "${next.name}"${where(live)}. It shows at the head of every reply, in list_boards and read_wall, and as the title of every script out${several ? `, where each board follows it as an episode line (Episode 1 of ${next.boards.length} · ${next.boards[0].name})` : ""}. The boards keep their names.`, next);
+    return ok(`Project renamed to "${next.name}"${where(live)}.${project.nameOpen ? " Its name is decided; the open words are gone." : ""} It shows at the head of every reply, in list_boards and read_wall, and as the title of every script out${several ? `, where each board follows it as an episode line (Episode 1 of ${next.boards.length} · ${next.boards[0].name})` : ""}. The boards keep their names.`, next);
   },
 );
 
@@ -3740,13 +3757,17 @@ server.registerTool(
   {
     title: "Start a project",
     description:
-      "Through the account door: start a new project of the writer's with this name — one empty board, nothing on it — and work it from now on. The writer sees it under Projects on every device. board names the first board; boardOpen leaves its name open in the writer's words instead (\"the pilot, or the film\"), so a board born from a maybe is not silently \"Board 1\".",
-    inputSchema: { name: z.string().min(1), board: z.string().optional(), boardOpen: z.string().optional(), pages: pagesSchema.optional(), minutes: z.number().positive().optional() },
+      "Through the account door: start a new project of the writer's with this name — one empty board, nothing on it — and work it from now on. The writer sees it under Projects on every device. A title not decided: open with the writer's words (\"The Allotments, or Plot 14\") instead of a name, and the project starts as Untitled project with those words beside it. board names the first board; boardOpen leaves its name open in the writer's words instead (\"the pilot, or the film\"), so a board born from a maybe is not silently \"Board 1\".",
+    inputSchema: { name: z.string().min(1).optional(), open: z.string().optional(), board: z.string().optional(), boardOpen: z.string().optional(), pages: pagesSchema.optional(), minutes: z.number().positive().optional() },
   },
   async (args) => {
     const account = await findAccount();
     if (!account) return shut("No account door: there is one project here, the open one. Set PLOTCODER_EMAIL and PLOTCODER_PASSWORD to start another on the writer's account.");
-    let record = renameProject(emptyProject(), args.name.trim());
+    if (!args.name?.trim() && !args.open?.trim()) return ok("Say which: name (the title), or open (the writer's words for why the title is not decided — the project starts as \"Untitled project\" with those words beside it).");
+    let record = emptyProject();
+    if (args.name?.trim()) record = renameProject(record, args.name.trim());
+    // A project born from a maybe is born open on its name (R61's edge): open holds the writer's words.
+    if (args.open?.trim()) record = setProjectNameOpen(record, args.open);
     if (args.board?.trim()) record = renameBoard(record, record.activeBoardId, args.board.trim());
     // A board born from a maybe is born open on its name (R61): boardOpen holds the writer's words.
     if (args.boardOpen?.trim()) record = setBoardNameOpen(record, record.activeBoardId, args.boardOpen);
@@ -3760,7 +3781,7 @@ server.registerTool(
     joinPresence(record.id);
     const targetLine = target === undefined ? ` Its target is ${formatPages(state.targetEighths)} pages, the default for a feature; set_target for a pilot or a half-hour, or pass pages or minutes here.` : ` Its target is ${formatPages(state.targetEighths)} pages.`;
     const first = record.boards[0];
-    const nameOpenLine = first.nameOpen ? ` The board's name is left open, by the writer's word: "${first.nameOpen}"; rename_board decides it.` : "";
+    const nameOpenLine = `${record.nameOpen ? ` The project's name is left open, by the writer's word: "${record.nameOpen}"; rename_project decides it.` : ""}${first.nameOpen ? ` The board's name is left open, by the writer's word: "${first.nameOpen}"; rename_board decides it.` : ""}`;
     return ok(`Started "${record.name}" (${record.id}) with its first board "${first.name}" (${first.id}), and working it now, as ${account.email}.${targetLine}${nameOpenLine}${oneCallHint(record)}`, { id: record.id, name: record.name, boardId: first.id, boardName: first.name, boardNameOpen: first.nameOpen ?? "", targetEighths: state.targetEighths });
   },
 );
@@ -3856,6 +3877,63 @@ server.registerTool(
   },
 );
 
+// Help in the app (R64): the questions writers asked that the guide did not
+// answer. They are the app's, not a project's, so these two tools take the
+// maintainer's service role from the server's environment — the key never
+// ships, as the wipe script's does not — and every other door refuses them.
+async function questionsDoor() {
+  const key = process.env.SUPABASE_SERVICE_ROLE_KEY || process.env.PLOTCODER_SERVICE_ROLE_KEY;
+  if (!key) return null;
+  const { createClient } = await import("@supabase/supabase-js");
+  return createClient(process.env.SUPABASE_URL || SUPABASE_URL, key, { auth: { persistSession: false } });
+}
+const NO_QUESTIONS_DOOR = "The questions are the app's, not a project's: set SUPABASE_SERVICE_ROLE_KEY in the server's environment — the maintainer's key, never in the repo — and call again. A writer asks from the Help sheet; the answer goes into public/writers.html and back to them through answer_question.";
+
+server.registerTool(
+  "list_questions",
+  {
+    title: "The writers' questions",
+    description:
+      "The questions writers asked from the app's Help sheet that the guide did not answer, waiting first: who asked, when, the words. Maintainer only — needs the service role in the server's environment. Answer one with answer_question after the answer is in public/writers.html.",
+    inputSchema: { all: z.boolean().optional() },
+  },
+  async (args) => {
+    const db = await questionsDoor();
+    if (!db) return ok(NO_QUESTIONS_DOOR);
+    const { data, error } = await db.from("questions").select("id, email, question, asked_at, answered_at, answer, section").order("asked_at", { ascending: false });
+    if (error) return ok(`Could not read the questions: ${error.message}`);
+    const rows = args.all ? data : data.filter((row) => !row.answered_at);
+    const waiting = data.filter((row) => !row.answered_at).length;
+    const line = (row) => `  - ${row.id.slice(0, 8)} · ${String(row.asked_at).slice(0, 10)} · ${row.email} · "${row.question}" · ${row.answered_at ? `answered ${String(row.answered_at).slice(0, 10)}${row.section ? ` → ${row.section}` : ""}` : "waiting"}`;
+    return ok(
+      [`${waiting} waiting, ${data.length - waiting} answered.${args.all ? "" : " (all: true lists the answered ones too)"}`, ...(rows.length ? rows.map(line) : ["  (none)"])].join("\n"),
+      rows,
+    );
+  },
+);
+
+server.registerTool(
+  "answer_question",
+  {
+    title: "Answer a writer's question",
+    description:
+      "Mark a writer's question answered, with the answer in a sentence or two and the guide's section it went into (\"#s5\"), once the answer is in public/writers.html: the writer sees both under Your questions. Maintainer only — needs the service role in the server's environment. The guide is the answer; this is the promise kept.",
+    inputSchema: { id: z.string().min(1), answer: z.string().min(1), section: z.string().optional() },
+  },
+  async (args) => {
+    const db = await questionsDoor();
+    if (!db) return ok(NO_QUESTIONS_DOOR);
+    const { data: found, error: findError } = await db.from("questions").select("id, question, answered_at").ilike("id", `${args.id}%`);
+    if (findError) return ok(`Could not read the questions: ${findError.message}`);
+    if (!found?.length) return ok(`No question whose id starts "${args.id}". list_questions shows them.`);
+    if (found.length > 1) return ok(`${found.length} questions start "${args.id}": say more of the id.`);
+    const row = found[0];
+    const { error } = await db.from("questions").update({ answered_at: new Date().toISOString(), answer: args.answer.trim(), section: args.section?.trim() || null }).eq("id", row.id);
+    if (error) return ok(`Could not answer it: ${error.message}`);
+    return ok(`Answered "${row.question}"${args.section ? ` and filed it under ${args.section.trim()}` : ""}${row.answered_at ? " (it had been answered before; this replaces that)" : ""}. The writer sees it under Your questions. If the answer is not yet in public/writers.html, put it there and open the pull request: the guide is the answer, this list is the promise.`, { id: row.id });
+  },
+);
+
 server.registerTool(
   "export_project",
   {

package/src/board/agents.js

@@ -55,10 +55,10 @@ export const AGENTS = {
     "No opinions about how many beats there should be. Marking the turns a treatment plainly makes is reading it, not an opinion: mark them, say which, and let the writer strike or add.",
     "Page counts are estimates.",
     "Ask before delete_board, delete_project, empty_account, delete_account, unlock_numbers, remove_file, an import_project that replaces, or claim_account — the writer gives the email and the password; never invent one. export_project first, when something might be wanted back.",
-    "Do not invent people or a logline. What the treatment states — an age, a job, a bad knee — is not invented: it goes in the person's notes. An unnamed person is named by their role — Dana's mother, the dispatcher — which is a name until the writer gives one. A scene is one place and one stretch of time; a new place or time is a new card. A beat is a whole card; a setup arrow lands on the scene's card, so a payoff never needs a card of its own. Acts are groups titled Act one, Act two, when the treatment has them; the wall never asks whether an act is a sequence. Paper colour means nothing to the app. Under target is a fact to report plainly, like over; neither is a verdict. A thing the writer has not decided is an open card in their words (set_open), or an open field — the logline, the premise, a when, a board's name take open beside the value — never a guess to fill the field; a thing whose far end the writer knows and not where it is first seen — the letter, the ring — is a thread (create_thread) with an open start, and the wall asks from that end.",
+    "Do not invent people or a logline. What the treatment states — an age, a job, a bad knee — is not invented: it goes in the person's notes. An unnamed person is named by their role — Dana's mother, the dispatcher — which is a name until the writer gives one. A scene is one place and one stretch of time; a new place or time is a new card. A beat is a whole card; a setup arrow lands on the scene's card, so a payoff never needs a card of its own. Acts are groups titled Act one, Act two, when the treatment has them; the wall never asks whether an act is a sequence. Paper colour means nothing to the app. Under target is a fact to report plainly, like over; neither is a verdict. A thing the writer has not decided is an open card in their words (set_open), or an open field — the logline, the premise, a card's place or when, a board's or the project's name take open beside the value — never a guess to fill the field; a thing whose far end the writer knows and not where it is first seen — the letter, the ring — is a thread (create_thread) with an open start, and the wall asks from that end.",
   ],
   person:
-    "Give your agent the account door only on a machine you trust; it signs in as you and shows under People as “an agent, as you” while it runs. Wire the server before you start the agent's session, with the two sign-in lines beside it, and the agent has every tool from its first message; wired from inside a session, the server connects only on the next one. Your agent can also make your account: give it your email and a password of your choosing.",
+    "Give your agent the account door only on a machine you trust; it signs in as you and shows under People as “an agent, as you” while it runs. Wire the server before you start the agent's session, with the two sign-in lines beside it, and the agent has every tool from its first message; wired from inside a session, the server connects only on the next one. Your agent can also make your account: give it your email and a password of your choosing. Your own guide — how a writer uses PlotCoder, from the door to the script out, the agent first — is at https://plotcoder.com/writers.html.",
   guide: "https://plotcoder.com/guide.md",
   url: "https://plotcoder.com/llms.txt",
 };

package/src/board/fountain.js

@@ -124,6 +124,7 @@ export function toFountain(state, options = {}) {
     if (cast.length) marks.push(`with ${cast.join(", ")}`);
     if (note.plants) marks.push(note.plantsWhat ? `plants ${note.plantsWhat}` : "plants something to pay off later");
     if (note.open) marks.push(`open: ${note.open}`);
+    if (note.locationOpen) marks.push(`place open: ${note.locationOpen}`);
     if (note.whenOpen) marks.push(`when open: ${note.whenOpen}`);
     const onThreads = (state.threads ?? []).filter((thread) => thread.noteIds.includes(note.id)).map((thread) => thread.name);
     if (onThreads.length) marks.push(`thread: ${onThreads.join(", ")}`);

package/src/board/help.d.ts

@@ -0,0 +1,11 @@
+// Type surface for help.js — Help in the app (R64).
+
+export type GuideParagraph = { id: string; title: string; sub: string; text: string };
+export type HelpHit = { kind: "word" | "guide"; from: string; text: string; href: string | null };
+export type HelpWord = { name: string; sentence: string };
+
+export declare function helpWords(text: string): string[];
+/** The guide's page as paragraphs under their section and sub-head. */
+export declare function indexGuide(html: string): GuideParagraph[];
+/** The hits for a question: the words first, then the guide, by how many of the question's words each holds. Empty when nothing matches. */
+export declare function searchHelp(query: string, words: HelpWord[], guide: GuideParagraph[], limit?: number): HelpHit[];

package/src/board/help.js

@@ -0,0 +1,103 @@
+// Help in the app (R64): the writer's guide and the words, searched by the
+// writer's own words. Pure: the sheet fetches the guide's page and hands its
+// HTML here; the maintainer's tools and the tests never touch a browser.
+
+const FILLER = new Set(["a", "an", "the", "and", "or", "of", "to", "in", "on", "at", "is", "it", "i", "do", "how", "can", "my", "me", "we", "you", "your", "for", "with", "be", "what", "when", "where", "does", "did", "this", "that", "from", "as", "by", "are", "am", "if", "so", "up", "one", "two", "not", "no", "yes"]);
+
+/** The words of a question or a paragraph, lower-cased, without the filler. */
+export function helpWords(text) {
+  return (text ?? "")
+    .toLowerCase()
+    .replace(/[^\p{L}\p{N}\s]/gu, " ")
+    .split(/\s+/)
+    .filter((word) => word && !FILLER.has(word));
+}
+
+function stripTags(html) {
+  return html
+    .replace(/<[^>]+>/g, " ")
+    .replace(/&amp;/g, "&")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+/**
+ * The guide's page as paragraphs, each under its section (an <h2 id="sN">)
+ * and its sub-head (an <h3>), so a hit can say where it comes from and link
+ * there. Anything before the first section — the title, the contents — is
+ * not indexed.
+ */
+export function indexGuide(html) {
+  const paragraphs = [];
+  const sections = html.split(/(?=<h2 id="s\d+">)/g).slice(1);
+  for (const chunk of sections) {
+    const head = /^<h2 id="(s\d+)">([^<]*)<\/h2>/.exec(chunk);
+    if (!head) continue;
+    const id = head[1];
+    const title = stripTags(head[2]).replace(/^\d+\.\s*/, "");
+    let sub = "";
+    const parts = chunk.slice(head[0].length).split(/(?=<h3>)|(?=<p>)/g);
+    for (const part of parts) {
+      const h3 = /^<h3>([^<]*)<\/h3>/.exec(part);
+      if (h3) {
+        sub = stripTags(h3[1]);
+        continue;
+      }
+      const p = /^<p[^>]*>([\s\S]*?)<\/p>/.exec(part);
+      if (p) {
+        const text = stripTags(p[1]);
+        if (text) paragraphs.push({ id, title, sub, text });
+      }
+    }
+  }
+  return paragraphs;
+}
+
+/**
+ * The hits for a question: the words first, then the guide's paragraphs, each
+ * scored by how many of the question's words it holds (a word matches on its
+ * start, so "beats" finds "beat"). Nothing matched is an empty list, which is
+ * the sheet's cue to offer Ask.
+ */
+export function searchHelp(query, words, guide, limit = 8) {
+  // A plural asks for its singular too: "beats" finds "beat", "writers" finds "writer".
+  const stem = (word) => (word.length > 3 && word.endsWith("s") ? word.slice(0, -1) : word);
+  const wanted = [...new Set(helpWords(query).map(stem))];
+  if (wanted.length === 0) return [];
+  // A short question is answered whole; a long one may miss a word.
+  const needed = wanted.length <= 3 ? wanted.length : wanted.length - 1;
+  const holds = (have, want) => have.some((word) => word === want || word.startsWith(want));
+  const count = (text) => {
+    const have = helpWords(text);
+    let hits = 0;
+    for (const want of wanted) if (holds(have, want)) hits += 1;
+    return hits;
+  };
+  const scored = [];
+  for (const word of words ?? []) {
+    const hits = count(`${word.name} ${word.sentence}`);
+    if (hits < needed) continue;
+    // The entry named for the thing asked about comes first: "A beat" before a sentence that mentions beats.
+    const named = count(word.name) > 0 ? 2 : 0;
+    scored.push({ kind: "word", from: `The words · ${word.name}`, text: word.sentence, href: null, rank: hits + named, order: scored.length });
+  }
+  for (const paragraph of guide ?? []) {
+    const hits = count(`${paragraph.title} ${paragraph.sub} ${paragraph.text}`);
+    if (hits < needed) continue;
+    const headed = count(`${paragraph.title} ${paragraph.sub}`) > 0 ? 1 : 0;
+    scored.push({
+      kind: "guide",
+      from: `The guide · ${paragraph.title}${paragraph.sub ? ` · ${paragraph.sub}` : ""}`,
+      text: paragraph.text,
+      href: `/writers.html#${paragraph.id}`,
+      rank: hits + headed,
+      order: scored.length,
+    });
+  }
+  scored.sort((a, b) => b.rank - a.rank || (a.kind === "word" ? -1 : b.kind === "word" ? 1 : 0) || a.order - b.order);
+  return scored.slice(0, limit).map(({ kind, from, text, href }) => ({ kind, from, text, href }));
+}

package/src/board/project.d.ts

@@ -19,6 +19,8 @@ export type ProjectRecord = {
   version: number;
   id: string;
   name: string;
+  /** The writer's words for why the project's name is not decided (R61's edge), or empty; the name stands meanwhile. */
+  nameOpen: string;
   premise: string;
   /** The writer's words for why there is no premise yet (R61), or empty. */
   premiseOpen: string;
@@ -75,6 +77,8 @@ export declare function setPremise(project: ProjectRecord, premise: string, now?
 export declare function setPremiseOpen(project: ProjectRecord, words: string, now?: string): ProjectRecord;
 /** The writer's words for why a board's name is not decided (R61); the name stands meanwhile. */
 export declare function setBoardNameOpen(project: ProjectRecord, id: string, words: string, now?: string): ProjectRecord;
+/** The writer's words for why the project's name is not decided (R61's edge); the name stands meanwhile. */
+export declare function setProjectNameOpen(project: ProjectRecord, words: string, now?: string): ProjectRecord;
 export declare function boardById(project: ProjectRecord, id: string): BoardMeta | null;
 /** What a script going out is called: a named project is the title, its board beside it only when the project has several. */
 export declare function scriptTitles(project: ProjectRecord, board: BoardMeta | null | undefined): { title: string; episode?: string };

package/src/board/project.js

@@ -33,6 +33,7 @@ export function emptyProject(now = nowIso()) {
     version: PROJECT_VERSION,
     id: newId(),
     name: DEFAULT_PROJECT_NAME,
+    nameOpen: "",
     premise: "",
     premiseOpen: "",
     boards: [board],
@@ -87,6 +88,8 @@ export function normalizeProject(value, now = nowIso()) {
     ...rest,
     version: PROJECT_VERSION,
     name: trimmed(value.name, DEFAULT_PROJECT_NAME),
+    // A project named before R61's edge has no open name; the name stands until the writer says it is not decided.
+    nameOpen: openWords(value.nameOpen),
     premise: typeof value.premise === "string" ? value.premise.trim() : "",
     // A project written before R61 has no open premise (R61).
     premiseOpen: openWords(value.premiseOpen),
@@ -342,8 +345,16 @@ export function setActiveBoard(project, id, now = nowIso()) {
 
 export function renameProject(project, name, now = nowIso()) {
   const next = trimmed(name, "");
-  if (!next || next === project.name) return project;
-  return touch(project, { name: next }, now);
+  if (!next || (next === project.name && !(project.nameOpen ?? ""))) return project;
+  // A name decides the field: the open words go (R61's edge).
+  return touch(project, { name: next, nameOpen: "" }, now);
+}
+
+/** The writer's words for why the project's name is not decided (R61's edge), or "" to take them back; the name stands meanwhile. */
+export function setProjectNameOpen(project, words, now = nowIso()) {
+  const next = openWords(words);
+  if (next === (project.nameOpen ?? "")) return project;
+  return touch(project, { nameOpen: next }, now);
 }
 
 export function setPremise(project, premise, now = nowIso()) {

package/src/board/readWall.d.ts

@@ -72,7 +72,7 @@ export type WallReading = {
   /** Open cards (R59): the writer's words for what is not decided, in story order; not asked about while they stand. */
   open: Array<{ id: string; words: string; hides: FindingKind[] }>;
   /** Fields left open by the writer's word (R61): the board's logline, and each card's when, in story order. Listed, not asked. */
-  openFields: Array<{ field: "logline"; words: string } | { field: "when"; id: string; words: string }>;
+  openFields: Array<{ field: "logline"; words: string } | { field: "location"; id: string; words: string } | { field: "when"; id: string; words: string }>;
   /** Threads (R60): each named string with its cards in story order and which ends are open. */
   threads: Array<{ id: string; name: string; ids: string[]; startOpen: boolean; endOpen: boolean; /** Eighths from the first card's start to the last card's start; 0 with fewer than two cards. */ apart: number }>;
   /** Cards here that pay off a fold of another board (R58), composed by the door from the project. */

package/src/board/readWall.js

@@ -241,7 +241,8 @@ export function readWall(state, options = {}) {
   // A card that says no place, once the writer has started placing cards.
   // One question however many there are; a wall with no places at all is a
   // wall the writer has not placed yet, and is not asked.
-  const unplaced = order.filter((note) => askable(note) && !(note.location ?? "").trim());
+  // A place left open in the writer's words (R61's edge) is listed, not asked.
+  const unplaced = order.filter((note) => askable(note) && !(note.location ?? "").trim() && !(note.locationOpen ?? "").trim());
   if (unplaced.length > 0 && unplaced.length < order.length) {
     findings.push({
       kind: "unplaced",
@@ -535,6 +536,7 @@ export function readWall(state, options = {}) {
 function describeOpenFields(state, order) {
   const fields = [];
   if ((state.loglineOpen ?? "").trim()) fields.push({ field: "logline", words: state.loglineOpen.trim() });
+  for (const note of order) if ((note.locationOpen ?? "").trim()) fields.push({ field: "location", id: note.id, words: note.locationOpen.trim() });
   for (const note of order) if ((note.whenOpen ?? "").trim()) fields.push({ field: "when", id: note.id, words: note.whenOpen.trim() });
   return fields;
 }

package/src/board/reducer.d.ts

@@ -93,6 +93,8 @@ export type BoardNote = {
   when: string;
   /** The writer's words for why the when is not decided (R61), or empty; while they stand the when is blank and the reading lists them. */
   whenOpen: string;
+  /** The writer's words for why the place is not decided (R61's edge), or empty; while they stand the place is blank, listed, and not asked. */
+  locationOpen: string;
   /** The scene's text in Fountain (R23 b): action, cues, dialogue; empty until written. */
   text: string;
   createdAt: string;
@@ -186,6 +188,7 @@ export type Command =
       location?: string;
       when?: string;
       whenOpen?: string;
+      locationOpen?: string;
       open?: string;
       text?: string;
     }
@@ -216,7 +219,7 @@ export type Command =
   | { type: "set_plant"; ids: string[]; plants?: boolean; what?: string }
   | { type: "set_open"; ids: string[]; open: string }
   | { type: "set_payoff_board"; ids: string[]; boardId: string | null; noteId?: string | null }
-  | { type: "set_location"; ids: string[]; location: string }
+  | { type: "set_location"; ids: string[]; location?: string; open?: string }
   | { type: "set_when"; ids: string[]; when?: string; open?: string }
   | { type: "apply_template"; template: string; beats?: Array<{ name: string; prompt: string; at: number }> }
   | { type: "set_text"; id: string; text: string }

package/src/board/reducer.js

@@ -247,6 +247,8 @@ export function seedState(now = nowIso()) {
     lengthEighths: null,
     characterIds,
     location: "",
+    // The writer's words for why the place is not decided (R61), or nothing.
+    locationOpen: "",
     when: "",
     // The writer's words for why the when is not decided (R61), or nothing.
     whenOpen: "",
@@ -368,6 +370,8 @@ export function normalizeState(value) {
     const open = typeof note?.open === "string" ? note.open : "";
     // Cards written before R37 have no place; a scene is nowhere until it is.
     const location = typeof note?.location === "string" ? note.location : "";
+    // Cards written before R61's edge have no open place; a place is decided or blank until the writer says otherwise.
+    const locationOpen = typeof note?.locationOpen === "string" ? note.locationOpen : "";
     // Cards written before R55 have no when; a scene is at no time until it is.
     const when = typeof note?.when === "string" ? note.when : "";
     // Cards written before R61 have no open when; a when is decided or blank until the writer says otherwise.
@@ -386,6 +390,7 @@ export function normalizeState(value) {
       note.payoffNoteId === payoffNoteId &&
       note.open === open &&
       note.location === location &&
+      note.locationOpen === locationOpen &&
       note.when === when &&
       note.whenOpen === whenOpen &&
       note.text === text
@@ -393,7 +398,7 @@ export function normalizeState(value) {
       return note;
     }
     patched = true;
-    return { ...note, rank, lengthEighths, characterIds, plants, plantsWhat, payoffBoardId, payoffNoteId, open, location, when, whenOpen, text };
+    return { ...note, rank, lengthEighths, characterIds, plants, plantsWhat, payoffBoardId, payoffNoteId, open, location, locationOpen, when, whenOpen, text };
   });
 
   // Boards written before the production half (Roadmap 2, item 8) have no
@@ -636,7 +641,8 @@ export function applyCommand(state, command, now = nowIso()) {
         payoffBoardId: null,
         payoffNoteId: null,
         open: cleanOpen(command.open),
-        location: cleanPlace(command.location),
+        location: cleanOpen(command.locationOpen) ? "" : cleanPlace(command.location),
+        locationOpen: cleanOpen(command.locationOpen),
         when: cleanOpen(command.whenOpen) ? "" : cleanWhen(command.when),
         whenOpen: cleanOpen(command.whenOpen),
         text: typeof command.text === "string" ? command.text : "",
@@ -1165,6 +1171,7 @@ export function applyCommand(state, command, now = nowIso()) {
         payoffNoteId: null,
         open: "",
         location: "",
+        locationOpen: "",
         when: "",
         whenOpen: "",
         text: "",
@@ -1256,11 +1263,21 @@ export function applyCommand(state, command, now = nowIso()) {
     case "set_location": {
       const ids = new Set(command.ids);
       if (ids.size === 0) return { state, changed: false };
-      const location = cleanPlace(command.location);
+      // The place, or the writer's words for why there is none yet (R61's
+      // edge, round twenty entry 16): words clear the place, a place clears
+      // the words, open "" with a place does both in one command.
+      const hasOpen = typeof command.open === "string";
+      const locationOpen = hasOpen ? cleanOpen(command.open) : null;
+      const location = hasOpen ? (locationOpen ? "" : typeof command.location === "string" ? cleanPlace(command.location) : null) : cleanPlace(command.location);
       const touched = [];
       const notes = state.notes.map((note) => {
-        if (!ids.has(note.id) || note.location === location) return note;
-        const next = bump(note, { location }, now);
+        if (!ids.has(note.id)) return note;
+        const patch = {
+          location: location === null ? (note.location ?? "") : location,
+          locationOpen: locationOpen === null ? (location ? "" : (note.locationOpen ?? "")) : locationOpen,
+        };
+        if (patch.location === (note.location ?? "") && patch.locationOpen === (note.locationOpen ?? "")) return note;
+        const next = bump(note, patch, now);
         touched.push(next);
         return next;
       });

package/src/board/words.js

@@ -66,13 +66,18 @@ export const WORD_GROUPS = [
       {
         id: "open",
         name: "Open",
-        sentence: "A card the writer has not decided, in their words on its edge: the reading lists it and asks nothing else of it until the words are cleared. A field can be open the same way — the logline, the premise, a card's when, a board's name — the words where the value would be, listed and not asked.",
+        sentence: "A card the writer has not decided, in their words on its edge: the reading lists it and asks nothing else of it until the words are cleared. A field can be open the same way — the logline, the premise, a card's place or when, a board's or the project's name — the words where the value would be, listed and not asked.",
       },
       {
         id: "thread",
         name: "A thread",
         sentence: "A named string through the cards a thing runs through — the letter, the key, a subplot — with either end open until the writer ties it. Drawn on the wall as a dashed string, a ring where an end is loose; the reading asks where a loose thread is first seen, or where it comes out.",
       },
+      {
+        id: "help",
+        name: "Help",
+        sentence: "The button top right: type a question and the words and the writer's guide answer as you go; when nothing does, Ask sends it to the people who build PlotCoder, and the answer lands in the guide and under Your questions.",
+      },
       {
         id: "corner",
         name: "The folded corner",