@a-t-h-i/bot-lobby 0.6.7 → 0.6.9

package/src/lobby/knowledge.ts

@@ -0,0 +1,179 @@
+/**
+ * The Knowledge tab's side of the disk: every agent's knowledge files, one
+ * file read as entries with the user's notes on them, and the edits the user
+ * can make — replace, add or delete an entry, edit the whole file — plus
+ * notes. Every write goes through the compactor's path, which archives the
+ * previous version first (`archive/<Agent>/…bak`), so an edit can be undone by
+ * hand. An entry is found again by its exact text; when the file changed on
+ * disk since the tab drew it, the edit is refused with a line saying so.
+ */
+import { join } from "node:path";
+import { compactKnowledgeFile } from "../knowledge/compactor.ts";
+import { findEntry, insertAfter, parseEntries, removeEntry, replaceEntry, type KnowledgeEntry } from "../knowledge/edit.ts";
+import { addNote, moveNotes, readNotes, removeNote, removeNotesOn, type KnowledgeNote } from "../knowledge/notes.ts";
+import { AGENT_DIR_NAMES, KNOWLEDGE_FILES, knowledgeDir, type KnowledgeAgent } from "../knowledge/paths.ts";
+import { readFirstExisting } from "../knowledge/store.ts";
+import { dataRoot, readDataRoots } from "../state/project.ts";
+
+/** What each knowledge file is, in words. */
+export const FILE_LABELS: Record<string, string> = {
+  "knowledge.md": "Knowledge",
+  "decisions.md": "Decisions",
+  "completed-tasks.md": "Completed tasks",
+  "standards.md": "Standards",
+  "design-language.md": "Design language",
+  "engineering-standards.md": "Engineering standards",
+  "testing-standards.md": "Testing standards",
+};
+
+/** Who the agents are, as the lobby names them. */
+export const AGENT_LABELS: Record<KnowledgeAgent, string> = { master: "Master (oracle)", designer: "Designer", backend: "Backend", qa: "QA" };
+
+export interface KnowledgeFileInfo {
+  agent: KnowledgeAgent;
+  file: string;
+  label: string;
+  chars: number;
+  /** Past the compaction threshold: the Master should compact it. */
+  over: boolean;
+  notes: number;
+}
+
+export interface KnowledgeView extends KnowledgeFileInfo {
+  content: string;
+  entries: KnowledgeEntry[];
+  /** Notes on entries this file has. */
+  attached: KnowledgeNote[];
+  /** Notes whose entry has changed or gone: kept, shown apart. */
+  detached: KnowledgeNote[];
+}
+
+/** An entry picked in the tab: its text, and which of several identical ones it is. */
+export interface EntryRef {
+  text: string;
+  occurrence: number;
+}
+
+export interface KnowledgeDeps {
+  root: string;
+  configDir: string;
+  /** Characters past which a file is over its compaction threshold. */
+  threshold: () => number;
+  /** Backups of a file kept in the archive. */
+  backups: () => number;
+  sessionId?: () => string | undefined;
+  now?: () => Date;
+}
+
+const CHANGED = "that entry changed on disk since it was drawn — r reloads the file";
+
+export class KnowledgeBook {
+  private readonly deps: KnowledgeDeps;
+
+  constructor(deps: KnowledgeDeps) {
+    this.deps = deps;
+  }
+
+  private get data(): string {
+    return dataRoot(this.deps.root, this.deps.configDir);
+  }
+
+  private read(agent: KnowledgeAgent, file: string): string {
+    return readFirstExisting(readDataRoots(this.deps.root, this.deps.configDir).map((root) => join(knowledgeDir(root, agent), file)));
+  }
+
+  /** Every agent's files in the order the tab lists them, with their size and notes. */
+  files(): KnowledgeFileInfo[] {
+    const notes = readNotes(this.data);
+    return (Object.keys(AGENT_DIR_NAMES) as KnowledgeAgent[]).flatMap((agent) =>
+      KNOWLEDGE_FILES[agent].map((file) => {
+        const chars = this.read(agent, file).length;
+        return { agent, file, label: FILE_LABELS[file] ?? file, chars, over: chars > this.deps.threshold(), notes: notes.filter((note) => note.agent === agent && note.file === file).length };
+      }),
+    );
+  }
+
+  /** One file as entries with their notes. */
+  open(agent: KnowledgeAgent, file: string): KnowledgeView {
+    const content = this.read(agent, file);
+    const entries = parseEntries(content);
+    const notes = readNotes(this.data).filter((note) => note.agent === agent && note.file === file);
+    const known = new Set(entries.map((entry) => entry.text));
+    return {
+      agent,
+      file,
+      label: FILE_LABELS[file] ?? file,
+      chars: content.length,
+      over: content.length > this.deps.threshold(),
+      notes: notes.length,
+      content,
+      entries,
+      attached: notes.filter((note) => known.has(note.entry)),
+      detached: notes.filter((note) => !known.has(note.entry)),
+    };
+  }
+
+  /** Write a file's new content with the previous one archived; the notice says where it went. */
+  private write(agent: KnowledgeAgent, file: string, content: string): string {
+    compactKnowledgeFile({ dataRoot: this.data, agent, file, content, backupCount: this.deps.backups(), ...(this.deps.now ? { now: this.deps.now() } : {}) });
+    return `saved ${agent}/${file} — the version before is in archive/${AGENT_DIR_NAMES[agent]}`;
+  }
+
+  /** Replace one entry with `text`, exactly as written; its notes move with it. */
+  edit(agent: KnowledgeAgent, file: string, ref: EntryRef, text: string): string {
+    const content = this.read(agent, file);
+    const entry = findEntry(content, ref.text, ref.occurrence);
+    if (!entry) return CHANGED;
+    if (!text.trim()) return "nothing to save — d d deletes an entry, esc cancels";
+    const next = replaceEntry(content, entry, text);
+    if (next.trim() === content.trim()) return "nothing changed";
+    const notice = this.write(agent, file, next);
+    const moved = moveNotes(this.data, agent, file, entry.text, text.replace(/\s+$/, ""), this.deps.now?.());
+    return `${notice}${moved > 0 ? `; ${moved} note${moved === 1 ? "" : "s"} stayed with it` : ""}`;
+  }
+
+  /** Add a bullet after an entry (at the end when there is none). */
+  add(agent: KnowledgeAgent, file: string, after: EntryRef | undefined, text: string): string {
+    const content = this.read(agent, file);
+    const entry = after ? findEntry(content, after.text, after.occurrence) : undefined;
+    if (after && !entry) return CHANGED;
+    const next = insertAfter(content, entry, text);
+    if (next === content) return "nothing to add";
+    return this.write(agent, file, next);
+  }
+
+  /** Delete an entry, and the notes on it. */
+  remove(agent: KnowledgeAgent, file: string, ref: EntryRef): string {
+    const content = this.read(agent, file);
+    const entry = findEntry(content, ref.text, ref.occurrence);
+    if (!entry) return CHANGED;
+    const notice = this.write(agent, file, removeEntry(content, entry));
+    const gone = removeNotesOn(this.data, agent, file, entry.text, this.deps.now?.());
+    return `${notice}${gone > 0 ? `; its ${gone} note${gone === 1 ? "" : "s"} went with it` : ""}`;
+  }
+
+  /** Replace a whole file (edited in pi's editor). */
+  replaceFile(agent: KnowledgeAgent, file: string, text: string): string {
+    const content = this.read(agent, file);
+    if (text.trim() === content.trim()) return "nothing changed";
+    return this.write(agent, file, text);
+  }
+
+  /** Leave a note on an entry: every agent that reads this knowledge reads it under the entry. */
+  comment(agent: KnowledgeAgent, file: string, ref: EntryRef, text: string): string {
+    const entry = findEntry(this.read(agent, file), ref.text, ref.occurrence);
+    if (!entry) return CHANGED;
+    try {
+      addNote(this.data, { agent, file, entry: entry.text, text, ...(this.deps.sessionId?.() ? { by: this.deps.sessionId!()! } : {}) }, this.deps.now?.());
+    } catch (error) {
+      return (error as Error).message;
+    }
+    return "note saved — every agent reads it under this entry";
+  }
+
+  /** Take a note back. */
+  unnote(id: string): string {
+    removeNote(this.data, id, this.deps.now?.());
+    return "note removed";
+  }
+}

package/src/lobby/layout.ts

@@ -91,6 +91,9 @@ export function wrapHanging(lead: string, text: string, width: number): string[]
   return body.map((line, index) => `${index === 0 ? lead : " ".repeat(indent)}${line}`);
 }
 
+/** The mark before a git branch name, in the lobby's title and a task's details. */
+export const BRANCH_GLYPH = "⎇";
+
 /** `── Title ───────` spanning `width`; `right` sits at the far end when it fits. */
 export function rule(width: number, title = "", theme?: LobbyTheme, right = "", color: LobbyColor = "borderMuted"): string {
   if (width <= 0) return "";
@@ -268,21 +271,84 @@ export function scrollThumb(total: number, rows: number, start: number): { from:
   return { from, to: from + size };
 }
 
-/** Page buttons in the bottom border of a pane that scrolls: two pages up, one up, one down, two down. */
-export const PAGER = "▲▲ ▲ ▼ ▼▼";
-/** Columns the pager takes with a space on each side. */
-export const PAGER_WIDTH = PAGER.length + 2;
-/** Narrowest box that has room for the pager beside its corners. */
-const PAGER_MIN_WIDTH = PAGER_WIDTH + 6;
-
-/** Which page button a column of a scrollable pane's bottom border is: -2, -1, 1 or 2 pages (negative up), or undefined. */
-export function pagerButton(width: number, column: number): -2 | -1 | 1 | 2 | undefined {
-  if (width < PAGER_MIN_WIDTH) return undefined;
-  const from = column - width;
-  if (from >= -12 && from <= -10) return -2;
-  if (from >= -9 && from <= -7) return -1;
-  if (from >= -6 && from <= -5) return 1;
-  if (from >= -4 && from <= -2) return 2;
+/** Lines a page moves a pane: its rows less one, so a line of context carries over. */
+export function pageStep(rows: number): number {
+  return Math.max(1, rows - 1);
+}
+
+/** How many pages a pane showing `rows` lines at a time holds out of `total`. */
+export function pageCount(total: number, rows: number): number {
+  return total <= rows ? 1 : 1 + Math.ceil((total - rows) / pageStep(rows));
+}
+
+/**
+ * The page a pane showing lines from `start` is on, counted so that the top is
+ * page 1 and the bottom the last, and a page's worth of scrolling from either
+ * end lands exactly on the next number: a log that opens at its newest line
+ * and a detail that opens at its first both step through the same numbers.
+ */
+export function pageOf(total: number, rows: number, start: number): number {
+  const end = Math.max(0, total - rows);
+  const behind = Math.ceil(Math.max(0, end - Math.max(0, start)) / pageStep(rows));
+  return Math.max(1, pageCount(total, rows) - behind);
+}
+
+/** One piece of the pager: a button, where the pane is, or what sits between them. */
+export interface PagerPart {
+  text: string;
+  role: "up" | "down" | "where" | "between";
+}
+
+/** Fewest columns of border kept either side of the pager, beside its two spaces. */
+const PAGER_MARGIN = 3;
+
+/**
+ * The pager in a scrolling pane's bottom border, as words a newcomer can read:
+ * `▲ prev · page 2/5 · next ▼`, shortening to `▲ prev · 2/5 · next ▼` and
+ * `▲ 2/5 ▼` as the pane narrows, and to nothing when even that will not fit
+ * in `room` columns. The page number is padded to the width of the page count,
+ * so the buttons stay where they are as it changes and a click can be traced
+ * from the pane's size alone.
+ */
+export function pager(total: number, rows: number, start: number, room: number): PagerPart[] | undefined {
+  const pages = pageCount(total, rows);
+  const count = String(pages);
+  const of = `${String(pageOf(total, rows, start)).padStart(count.length)}/${pages}`;
+  const between = (text: string): PagerPart => ({ text, role: "between" });
+  const up = (text: string): PagerPart => ({ text, role: "up" });
+  const down = (text: string): PagerPart => ({ text, role: "down" });
+  const where = (text: string): PagerPart => ({ text, role: "where" });
+  const variants: PagerPart[][] = [
+    [up("▲ prev"), between(" · "), where(`page ${of}`), between(" · "), down("next ▼")],
+    [up("▲ prev"), between(" · "), where(of), between(" · "), down("next ▼")],
+    [up("▲"), between(" "), where(of), between(" "), down("▼")],
+  ];
+  return variants.find((parts) => parts.reduce((sum, part) => sum + textWidth(part.text), 0) <= room);
+}
+
+/** Columns a box of `width` leaves for the pager's text: two spaces around it and a margin of border on each side. */
+function pagerRoom(width: number): number {
+  return width - 2 - 2 - PAGER_MARGIN;
+}
+
+/**
+ * Which button a column of a scrollable pane's bottom border is: -1 (a page
+ * up) or 1 (a page down), or undefined. The buttons take their words and the
+ * space beside them, so a click a little off still lands.
+ */
+export function pagerButton(width: number, column: number, total: number, rows: number): -1 | 1 | undefined {
+  const parts = pager(total, rows, 0, pagerRoom(width));
+  if (!parts) return undefined;
+  const size = parts.reduce((sum, part) => sum + textWidth(part.text), 0);
+  // The text ends one space before the corner: `… next ▼ ╯`.
+  const origin = width - 2 - size;
+  let at = origin;
+  for (const part of parts) {
+    const from = part.role === "up" ? origin - 1 : at;
+    const to = part.role === "down" ? width - 1 : at + textWidth(part.text);
+    if (column >= from && column < to) return part.role === "up" ? -1 : part.role === "down" ? 1 : undefined;
+    at += textWidth(part.text);
+  }
   return undefined;
 }
 
@@ -309,9 +375,20 @@ export function box(width: number, height: number, content: readonly string[], o
   const thumb = options.scroll ? scrollThumb(options.scroll.total, height - 2, options.scroll.start) : undefined;
   const rightEdge = (row: number) => (thumb && row >= thumb.from && row < thumb.to ? paint(theme, focused ? "accent" : "muted", "┃") : edge("│"));
   const rows = fill(content, height - 2).map((line, row) => `${edge("│")} ${fit(line, inner)} ${rightEdge(row)}`);
-  // A pane with more lines than rows carries page buttons in its bottom border; `pagerButton` finds them again for clicks.
-  const pager = thumb && width >= PAGER_MIN_WIDTH ? ` ${PAGER} ` : "";
-  const bottom = `${edge("╰")}${edge("─".repeat(width - 2 - textWidth(pager)))}${pager ? paint(theme, focused ? "accent" : "muted", pager) : ""}${edge("╯")}`;
+  // A pane with more lines than rows carries a pager in its bottom border; `pagerButton` finds its buttons again for clicks.
+  const parts = thumb && options.scroll ? pager(options.scroll.total, height - 2, options.scroll.start, pagerRoom(width)) : undefined;
+  const atTop = (options.scroll?.start ?? 0) <= 0;
+  const atEnd = options.scroll ? options.scroll.start >= options.scroll.total - (height - 2) : true;
+  const paintPart = (part: PagerPart): string => {
+    if (part.role === "between") return paint(theme, "dim", part.text);
+    if (part.role === "where") return paint(theme, focused ? "text" : "muted", part.text);
+    // A button that cannot go further is dimmed: the pane is at that end.
+    if (part.role === "up" ? atTop : atEnd) return paint(theme, "dim", part.text);
+    return bold(theme, paint(theme, focused ? "accent" : "text", part.text));
+  };
+  const pagerText = parts ? ` ${parts.map(paintPart).join("")} ` : "";
+  const pagerWidth = parts ? parts.reduce((sum, part) => sum + textWidth(part.text), 0) + 2 : 0;
+  const bottom = `${edge("╰")}${edge("─".repeat(width - 2 - pagerWidth))}${pagerText}${edge("╯")}`;
   return [top, ...rows, bottom];
 }
 

package/src/lobby/planner.ts

@@ -22,14 +22,18 @@ import { loadPrompt } from "../prompts/loader.ts";
 import { compilePrompt } from "../prompts/compiler.ts";
 import { withFallback } from "../execution/fallback.ts";
 import { runPiAgent, spawnPiProcess, type PiStreamEvent, type ProcessRunner } from "../execution/pi-runner.ts";
+import { grantOption, type Grant } from "../excalidraw/sessions.ts";
 import { describeToolCall } from "../pi/activity.ts";
 import { appendMetrics, type MetricRecord } from "../state/metrics.ts";
 import { savePlannedTask, type IssueRef, type PlannedTask } from "../state/backlog.ts";
+import { planSteps } from "../pi/plan-checklist.ts";
+import { KEEP_WHOLE, MAX_SPLIT_REVISIONS, partBrief, partInfo, parseSplit, splitFailedQuestion, splitLabel, splitProblems, splitPrompt, splitQuestion, splitRequest, type SplitProposal } from "./split.ts";
+import type { AskQuestion, AskResult } from "../ask/types.ts";
 import { PANEL_MEMBERS, type PanelMember } from "../schemas/configuration.ts";
 import { truncate } from "../text.ts";
 import type { LobbyFeed } from "./feed.ts";
 import type { QuickFixProfile } from "./quickfix.ts";
-import { MAX_QUESTIONS, type AskResult } from "./ask.ts";
+import { MAX_QUESTIONS } from "./ask.ts";
 import type { Classifier } from "../classifier/classifier.ts";
 import { chooseSeats } from "../classifier/seats.ts";
 import { autoAnswer, type AutoAnswer } from "../classifier/answers.ts";
@@ -71,6 +75,13 @@ export interface PanelQuestion extends AskedQuestion {
   from: string;
 }
 
+/** One of the panel's questions as the user's reply settled it: answered, or left open (`answer` absent). */
+export interface SettledQuestion {
+  from: string;
+  question: string;
+  answer?: string;
+}
+
 export interface PlannerMessage {
   role: "you" | "planner";
   text: string;
@@ -79,6 +90,8 @@ export interface PlannerMessage {
   questions?: PanelQuestion[];
   /** Questions the classifier answered with their recommended option instead of asking. */
   decided?: AutoAnswer[];
+  /** On the user's reply: which of the questions before it were answered, so they are never asked again. */
+  settled?: SettledQuestion[];
 }
 
 /** The oracle's reply: its verdict, title, own questions and the draft plan. */
@@ -337,6 +350,8 @@ export function plannerTranscript(messages: readonly PlannerMessage[], seed?: Pl
     lines.push(message.role === "you" ? "### User" : "### Panel", "", body, "");
     if (message.decided && message.decided.length > 0) lines.push(decidedBlock(message.decided), "");
   }
+  const settled = messages.flatMap((message) => message.settled ?? []);
+  if (settled.length > 0) lines.push(settledBlock(settled), "");
   if (draft) lines.push("## The oracle's current draft plan", "", truncate(draft, 8000), "");
   lines.push(closing);
   return lines.join("\n");
@@ -356,6 +371,55 @@ export function decidedBlock(decided: readonly AutoAnswer[]): string {
   ].join("\n");
 }
 
+/** One line of at most `max` characters, for the activity log. */
+function brief(text: string, max: number): string {
+  const flat = text.replace(/\s+/g, " ").trim();
+  return flat.length > max ? `${flat.slice(0, max - 1)}…` : flat;
+}
+
+/** Two questions this alike (by shared words) ask the same thing. */
+const SAME_QUESTION = 0.8;
+
+/** Words that carry no topic: a rewording changes them without changing the question. */
+const FILLER = new Set(["a", "an", "the", "of", "to", "in", "on", "at", "for", "with", "and", "or", "is", "are", "be", "been", "it", "its", "this", "that", "do", "does", "did", "we", "you", "i", "should", "would", "could", "can", "will", "shall", "must", "which", "what", "how", "so", "as", "by", "from", "than", "then", "us", "our", "your"]);
+
+function questionWords(text: string): Set<string> {
+  const words = text.toLowerCase().replace(/[^a-z0-9\s]+/g, " ").split(/\s+/).filter(Boolean);
+  const content = words.filter((word) => !FILLER.has(word));
+  return new Set(content.length > 0 ? content : words);
+}
+
+/** Whether two questions ask the same thing: the same topic words in any order, or nearly all of them. */
+export function sameQuestion(a: string, b: string): boolean {
+  const left = questionWords(a);
+  const right = questionWords(b);
+  if (left.size === 0 || right.size === 0) return false;
+  let shared = 0;
+  for (const word of left) if (right.has(word)) shared += 1;
+  if (shared === left.size && shared === right.size) return true;
+  return Math.min(left.size, right.size) >= 3 && shared / (left.size + right.size - shared) >= SAME_QUESTION;
+}
+
+/**
+ * Split a round's questions into those still to ask and the repeats of ones
+ * the user already settled (answered, or left for the oracle to decide): the
+ * user never gets the same question twice, whatever the models write.
+ */
+export function withoutSettled(questions: readonly PanelQuestion[], settled: readonly SettledQuestion[]): { asked: PanelQuestion[]; repeats: PanelQuestion[] } {
+  const asked: PanelQuestion[] = [];
+  const repeats: PanelQuestion[] = [];
+  for (const question of questions) (settled.some((entry) => sameQuestion(entry.question, question.text)) ? repeats : asked).push(question);
+  return { asked, repeats };
+}
+
+/** What the user settled, as every seat and the oracle read it: closed questions, never to be asked again. */
+export function settledBlock(settled: readonly SettledQuestion[]): string {
+  return [
+    "## Already settled with the user (closed: never ask these again, in any wording)",
+    ...settled.map((entry) => `- [${entry.from}] ${entry.question} → ${entry.answer ? entry.answer.replace(/\s*\n\s*/g, " / ") : "(left unanswered: decide it yourself with its recommended option and list it under Assumptions)"}`),
+  ].join("\n");
+}
+
 /** The seats' output for the oracle: each seat's status, questions and notes, or its failure. */
 export function panelSection(outcomes: readonly MemberOutcome[]): string {
   if (outcomes.length === 0) return "## Panel this round\n\nNo domain seats this round; you are planning alone.";
@@ -439,6 +503,8 @@ export class PlanningSession {
   saved?: PlannedTask;
   /** Questionnaires answered so far for this round's questions, so stopping one resumes where it left off. */
   answered: AskResult[] = [];
+  /** The tasks the plan was saved as when it was split (`saved` is the first). */
+  savedParts: PlannedTask[] = [];
   /** Comments on draft lines, sent with the user's next turn. */
   lineComments: LineComment[] = [];
   /** How the latest round ran under the round limit. */
@@ -498,21 +564,30 @@ export class PlanningSession {
     return this.seats.has(member);
   }
 
-  /** Add the user's message (the idea, or answers), with any line comments, and run a round. */
-  async send(text: string): Promise<void> {
+  /**
+   * Add the user's message (the idea, or answers), with any line comments, and
+   * run a round. `settled` says which of the open questions the message
+   * answered (or left), so the panel is never allowed to ask them again.
+   */
+  async send(text: string, settled?: readonly SettledQuestion[]): Promise<void> {
     this.autoContinued = false;
-    await this.post(text);
+    await this.post(text, settled);
   }
 
-  private async post(text: string): Promise<void> {
+  private async post(text: string, settled?: readonly SettledQuestion[]): Promise<void> {
     const body = [text.trim(), commentBlock(this.lineComments)].filter(Boolean).join("\n\n");
     if (!body) return;
     if (this.busy) throw new Error("the panel is still thinking");
     this.lineComments = [];
-    this.messages = [...this.messages, { role: "you", text: body, at: Date.now() }];
+    this.messages = [...this.messages, { role: "you", text: body, at: Date.now(), ...(settled && settled.length > 0 ? { settled: [...settled] } : {}) }];
     await this.turn();
   }
 
+  /** Every question the user has settled so far, oldest first. */
+  get settled(): SettledQuestion[] {
+    return this.messages.flatMap((message) => message.settled ?? []);
+  }
+
   /** The round's questions still wait for answers. */
   get awaitingAnswers(): boolean {
     return !this.busy && this.questions.length > 0;
@@ -574,6 +649,121 @@ export class PlanningSession {
     return this.saved;
   }
 
+  /** Save each part of a split plan as its own pending task, in order, each knowing the others. */
+  saveParts(proposal: SplitProposal, now = new Date()): PlannedTask[] {
+    const plan = this.reply?.plan;
+    if (!plan) throw new Error("there is no draft plan to save yet");
+    const steps = planSteps(plan);
+    const group = `SPLIT-${now.getTime().toString(36)}`;
+    // Part 1 is saved last of all timestamps' newest, so the newest-first pending list reads in part order.
+    const parts = proposal.tasks.map((task, index) => savePlannedTask(this.deps.root, this.deps.configDir, {
+      title: task.title,
+      brief: partBrief({ plan, steps, proposal, index }),
+      ...(this.seed ? { issue: this.seed.issue } : {}),
+      split: partInfo(proposal, index, group),
+    }, new Date(now.getTime() + (proposal.tasks.length - index))));
+    this.savedParts = parts;
+    this.saved = parts[0];
+    this.deps.feed?.log(ORACLE_LABEL, `split the plan into ${parts.length} tasks: ${parts.map((part) => part.id).join(", ")}`, "success");
+    this.deps.onChange?.();
+    return parts;
+  }
+
+  /**
+   * The oracle's proposal for splitting the plan: run, read, and checked
+   * against the rules (once more with the problems when it breaks one).
+   * `feedback` is the user's change request on an earlier proposal. A string
+   * is the reason there is no proposal.
+   */
+  private async proposeSplit(plan: string, steps: readonly string[], feedback: { previous: SplitProposal; words: string } | undefined, signal: AbortSignal): Promise<SplitProposal | string> {
+    const profile = this.deps.profile();
+    const title = this.title ?? "the plan";
+    let rejected: string[] = [];
+    let reason = "";
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      this.step = attempt === 0 ? "deciding how to split the plan" : "fixing the split";
+      this.deps.onChange?.();
+      const lead = await this.run(ORACLE_LABEL, "planner", profile, {
+        task: splitRequest({ title, plan, steps, ...(feedback ? { revision: feedback } : {}), ...(rejected.length > 0 ? { rejected } : {}) }),
+        systemPrompt: splitPrompt(profile.instructions),
+        tools: this.tools(PLANNER_TOOLS),
+        ...grantOption("planner"),
+      }, signal, (step) => (this.step = step));
+      if (signal.aborted) throw new Error("stopped");
+      if (lead.status !== "success") return lead.error ?? lead.status;
+      try {
+        const proposal = parseSplit(lead.output);
+        rejected = splitProblems(proposal, steps.length);
+        if (rejected.length === 0) return proposal;
+        reason = rejected[0]!;
+      } catch (error) {
+        rejected = [(error as Error).message];
+        reason = rejected[0]!;
+      }
+    }
+    return reason;
+  }
+
+  /**
+   * Save the plan as a pending task; when it has more steps than
+   * `splitAbove`, first let the oracle propose splitting it into up to five
+   * tasks and let the user decide: take it, keep the plan whole, or say what to
+   * change (the oracle revises, a few times). Nothing the user leaves open is
+   * decided for them: a questionnaire they put away saves nothing. Returns the
+   * notice for the lobby.
+   */
+  async saveWithSplit(ask: (questions: AskQuestion[], signal: AbortSignal) => Promise<AskResult>, options: { splitAbove: number }): Promise<string> {
+    const plan = this.reply?.plan;
+    if (!plan) throw new Error("there is no draft plan to save yet");
+    const steps = planSteps(plan);
+    const unagreed = this.reply?.status === "ready" ? "" : " (the panel had not agreed yet)";
+    const whole = () => `saved ${this.save().id} to the pending tasks — start it from the Tasks tab${unagreed}`;
+    if (options.splitAbove <= 0 || steps.length <= options.splitAbove) return whole();
+    if (this.busy) return "the panel is still working — save again once it is done, and the oracle will look at splitting this plan";
+    const controller = new AbortController();
+    this.controller = controller;
+    this.status = "thinking";
+    this.error = undefined;
+    this.deps.onChange?.();
+    try {
+      let proposal = await this.proposeSplit(plan, steps, undefined, controller.signal);
+      if (typeof proposal === "string") {
+        const reason = proposal;
+        this.deps.feed?.log(ORACLE_LABEL, `could not split the plan — ${reason.split("\n")[0]}`, "warning");
+        this.step = "waiting for you";
+        const answer = (await ask([splitFailedQuestion(reason)], controller.signal)).answers[0];
+        if (controller.signal.aborted) throw new Error("stopped");
+        return answer?.answer === "Save it as one task" ? whole() : "the plan was not saved — ctrl+s tries again";
+      }
+      for (let revisions = 0; ; revisions += 1) {
+        this.step = "waiting for you";
+        this.deps.onChange?.();
+        const result = await ask([splitQuestion({ stepCount: steps.length, proposal, steps, revisions })], controller.signal);
+        // A stopped questionnaire comes back empty too; it was stopped, not left open.
+        if (controller.signal.aborted) throw new Error("stopped");
+        const answer = result.answers[0];
+        if (!answer) return "the split question was left open, so nothing was saved — ctrl+s asks again";
+        if (answer.kind === "option") {
+          if (answer.answer === KEEP_WHOLE) return whole();
+          const parts = this.saveParts(proposal);
+          return `split into ${parts.length} tasks — ${parts.map((part) => part.id).join(", ")}; start them from the Tasks tab, in order${unagreed}`;
+        }
+        if (revisions >= MAX_SPLIT_REVISIONS) return `that was the last revision, and nothing was saved — ctrl+s asks again and the oracle starts over`;
+        const revised = await this.proposeSplit(plan, steps, { previous: proposal, words: answer.answer ?? "" }, controller.signal);
+        if (typeof revised === "string") return `the oracle could not apply that (${revised.split("\n")[0]}) — nothing was saved; ctrl+s asks again`;
+        proposal = revised;
+      }
+    } catch (error) {
+      if (controller.signal.aborted) return "stopped — nothing was saved";
+      return `could not save the plan: ${(error as Error).message}`;
+    } finally {
+      this.status = "idle";
+      this.step = undefined;
+      this.controller = undefined;
+      this.deps.onChange?.();
+    }
+  }
+
   private stepKey(who: string): string {
     return `plan-${who}-${this.attempts}`;
   }
@@ -590,7 +780,7 @@ export class PlanningSession {
     this.deps.onChange?.();
   }
 
-  private async run(label: string, kind: "planner" | "panel", profile: QuickFixProfile, request: { task: string; systemPrompt: string; tools: readonly string[] }, signal: AbortSignal, setStep: (step: string) => void, routedFrom?: string): Promise<RunOutcome> {
+  private async run(label: string, kind: "planner" | "panel", profile: QuickFixProfile, request: { task: string; systemPrompt: string; tools: readonly string[]; excalidraw?: Grant }, signal: AbortSignal, setStep: (step: string) => void, routedFrom?: string): Promise<RunOutcome> {
     const startedAt = Date.now();
     let outcome: RunOutcome;
     try {
@@ -658,6 +848,8 @@ export class PlanningSession {
       task: `${transcript}\n\nYou are ${label} on the planning panel${roundNote(this.turns, this.limit)}: ask your seat's open questions, or declare READY.`,
       systemPrompt: memberPrompt(member, profile.instructions),
       tools: this.tools(member === "researcher" ? RESEARCH_PANEL_TOOLS : PLANNER_TOOLS),
+      // A panel seat is the agent of its own kind: DEV is Backend, DESIGN the Designer.
+      ...grantOption(member),
     };
     const route = effort ? this.deps.effort?.plan(effort, { ...(profile.model ? { model: profile.model } : {}), thinking: profile.thinking }) : undefined;
     let outcome = await this.run(label, "panel", route ? { ...profile, model: route.model, thinking: route.thinking } : profile, request, signal, (step) => (state.step = step), route ? profileLabel(route.from) : undefined);
@@ -686,6 +878,8 @@ export class PlanningSession {
     this.turns += 1;
     this.attempts += 1;
     this.answered = [];
+    // The user's reply answers whatever was open: a round that then fails or is stopped must not put those questions to them again.
+    this.questions = [];
     const limit = this.limit;
     const mode = roundMode(this.turns, limit);
     this.mode = mode;
@@ -712,6 +906,7 @@ export class PlanningSession {
         task: `${transcript}\n\n${panelSection(outcomes)}\n\n${oracleClosing(mode, this.turns, limit)}`,
         systemPrompt: plannerPrompt(profile.instructions),
         tools: this.tools(PLANNER_TOOLS),
+        ...grantOption("planner"),
       }, controller.signal, (step) => (this.step = step));
       if (controller.signal.aborted) throw new Error("stopped");
       this.finishRound(outcomes, lead, mode);
@@ -824,7 +1019,9 @@ export class PlanningSession {
   private finishRound(outcomes: readonly MemberOutcome[], lead: RunOutcome, mode: RoundMode): void {
     const reply = lead.status === "success" ? parsePlannerReply(lead.output) : undefined;
     const seatQuestions = outcomes.flatMap((outcome) => (outcome.reply?.questions ?? []).map((question) => ({ ...question, from: MEMBER_LABELS[outcome.member] })));
-    let questions = roundQuestions(reply, seatQuestions);
+    const { asked, repeats } = withoutSettled(roundQuestions(reply, seatQuestions), this.settled);
+    let questions = asked;
+    if (repeats.length > 0) this.deps.feed?.log(ORACLE_LABEL, `held back ${repeats.length} question${repeats.length === 1 ? "" : "s"} you already settled: ${repeats.map((question) => brief(question.text, 60)).join("; ")}`, "info");
     const seatsReady = outcomes.every((outcome) => outcome.reply?.status === "ready");
     let ready = Boolean(reply && reply.status === "ready" && seatsReady);
     if (reply) {