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

package/src/lobby/runtime.ts

@@ -21,9 +21,12 @@ import { discardPlannedTask, listPlannedTasks, type PlannedTask } from "../state
 import { appendMetrics, readClassifierMetrics, readMetrics, type MetricStatus } from "../state/metrics.ts";
 import { describeToolCall } from "../pi/activity.ts";
 import { applyStatus, currentZenTask, isMinimized, onMinimizeChange, onRunUpdates, setMinimized, taskSnapshot } from "../pi/ui.ts";
-import { shortTitle } from "../text.ts";
+import { taskName } from "../text.ts";
+import { describeWorkspace, type WorkspaceInfo } from "../execution/workspace.ts";
+import { basename } from "node:path";
+import { stripStartFlags } from "../pi/start-flags.ts";
 import { isSubagentProcess } from "../pi/quiet.ts";
-import { modelRef, resolveLobbyProfile, resolvePanelProfile } from "../pi/model-support.ts";
+import { modelRef, resolveLobbyProfile, resolvePanelProfile, resolveReviewProfile } from "../pi/model-support.ts";
 import { modelLookup } from "../pi/tools.ts";
 import { startPlannedTask } from "../pi/start-task.ts";
 import { pendingRequest, setQuickFixHandoff, startRequest } from "../pi/route.ts";
@@ -34,11 +37,16 @@ import { classifier, effortFor, hintsFor } from "../classifier/instance.ts";
 import { checkThinking } from "../pi/model-support.ts";
 import { launchPi, SessionRegistry, type BackgroundSession, type SessionLauncher } from "./sessions.ts";
 import { SessionChats } from "./session-files.ts";
-import { answerMessage, askUser, questionnaires, type Asker } from "./ask.ts";
+import { answerMessage, askUser, questionnaires, settledQuestions, type Asker } from "./ask.ts";
 import { jobTitle, QuickFixQueue } from "./quickfix.ts";
 import { miniLine, type MiniInput } from "./mini.ts";
 import { PlanningSession, type PlannerSeed } from "./planner.ts";
 import { execCommand, IssuesState } from "./issues.ts";
+import { PullsState } from "./pulls.ts";
+import { PullReviews } from "./pr-review.ts";
+import { KnowledgeBook } from "./knowledge.ts";
+import { ExcalidrawBook } from "../excalidraw/sessions.ts";
+import { checkSession } from "../excalidraw/check.ts";
 import { LobbyView, type LiveSession, type LobbyHost, type SwitchTarget, type TabId } from "./view.ts";
 import { lobbyTheme } from "./theme.ts";
 import { deliverComments, onOwnerEvent, setAuto } from "../pi/owner.ts";
@@ -61,6 +69,10 @@ interface Runtime {
   quickfix: QuickFixQueue;
   planner?: PlanningSession;
   issues: IssuesState;
+  pulls: PullsState;
+  reviews: PullReviews;
+  knowledge: KnowledgeBook;
+  excalidraw: ExcalidrawBook;
   unsubscribeFeed?: () => void;
   /** Puts the panel's questions to the user: the questionnaire unless a test sets another. */
   asker?: Asker;
@@ -70,6 +82,9 @@ interface Runtime {
   mouse: boolean;
   /** Settings opened from the lobby are on screen; the lobby stays aside until they close. */
   inSettings: boolean;
+  /** The repository (or folder) and branch the lobby's title shows, and whether git is being asked now. */
+  workspace: WorkspaceInfo;
+  readingWorkspace: boolean;
 }
 
 let runtime: Runtime | undefined;
@@ -265,7 +280,8 @@ function startSession(state: Runtime, start: { request?: string; plan?: PlannedT
     const starting = backgroundSessions().find((session) => session.alive && session.planId === plan.id);
     if (starting) return `${plan.id} is already starting in ${starting.name}`;
   }
-  const name = plan?.title ?? shortTitle(request!);
+  // A request may lead with flags (`--worktree add login`); the session is named after what follows them.
+  const name = taskName(plan?.title ?? (stripStartFlags(request!) || request!));
   try {
     const session = sessionRegistry().start(state.ctx.cwd, { name, ...(plan ? { planId: plan.id } : { request: request! }), ...(start.auto ? { auto: true } : {}) }, sessionModel(state.ctx));
     lobbyFeed.log("LOBBY", `started "${name}" in a new session`, "success");
@@ -445,6 +461,15 @@ function deleteTask(state: Runtime, taskId: string, where: "list" | "archive"):
   return `deleted ${taskId} for good`;
 }
 
+/** What a pull request review runs on: QA's model, thinking and time limit. */
+function reviewProfile(state: Runtime) {
+  return resolveReviewProfile(loadConfig(), {
+    lookup: modelLookup(state.ctx),
+    sessionModel: sessionModel(state.ctx),
+    warn: (message) => state.ctx.ui.notify(message, "warning"),
+  });
+}
+
 function seatProfile(state: Runtime, member: PanelMember) {
   return resolvePanelProfile(loadConfig(), member, {
     lookup: modelLookup(state.ctx),
@@ -485,6 +510,26 @@ function panelAsker(state: Runtime): Asker {
   return state.asker ?? askUser;
 }
 
+/**
+ * Save the plan as a pending task. A plan with many steps is first split by
+ * the oracle into up to five tasks, which the user takes, changes or declines
+ * in a questionnaire; the split's questions open over the lobby like the
+ * panel's. Returns a notice for the lobby.
+ */
+export async function savePlan(state: Runtime | undefined = runtime): Promise<string> {
+  const session = state?.planner;
+  if (!state || !session) return "no planning session";
+  if (state.asking) return "a questionnaire is already open";
+  state.asking = true;
+  try {
+    const asker = panelAsker(state);
+    return await session.saveWithSplit((questions, signal) => asker(questions, state.ctx, signal), { splitAbove: loadConfig().lobby.splitPlanAbove });
+  } finally {
+    state.asking = false;
+    rerender();
+  }
+}
+
 /**
  * The oracle puts the round's questions to the user, one at a time; answered
  * questionnaires are kept if the user stops, so the next call resumes there.
@@ -514,7 +559,7 @@ export async function answerPanel(state: Runtime | undefined = runtime): Promise
       session.answered = [];
       return "nothing was answered — the questions stay open";
     }
-    void session.send(message);
+    void session.send(message, settledQuestions(session.questions, session.answered));
     return "answers sent — the panel is on the next round";
   } catch (error) {
     return `could not put the questions: ${(error as Error).message}`;
@@ -524,6 +569,22 @@ export async function answerPanel(state: Runtime | undefined = runtime): Promise
   }
 }
 
+/** Read the repository name and branch again, off the render path; the title repaints when they changed. */
+function refreshWorkspace(state: Runtime): void {
+  if (state.readingWorkspace) return;
+  state.readingWorkspace = true;
+  describeWorkspace(state.ctx.cwd)
+    .then((info) => {
+      if (runtime !== state || (info.name === state.workspace.name && info.branch === state.workspace.branch)) return;
+      state.workspace = info;
+      rerender();
+    })
+    .catch(() => {})
+    .finally(() => {
+      state.readingWorkspace = false;
+    });
+}
+
 function host(state: Runtime, tui: TUI): LobbyHost {
   return {
     rows: () => tui.terminal.rows,
@@ -550,6 +611,7 @@ function host(state: Runtime, tui: TUI): LobbyHost {
     planner: () => state.planner,
     newPlanner: (seed, seats) => newPlanner(state, seed, seats),
     answerPanel: () => answerPanel(state),
+    savePlan: () => savePlan(state),
     defaultPanel: () => loadConfig().lobby.planningPanel,
     planningRounds: () => loadConfig().lobby.maxPlanningRounds,
     issuesEnabled: () => loadConfig().lobby.issues,
@@ -562,10 +624,18 @@ function host(state: Runtime, tui: TUI): LobbyHost {
       return `${profile.model ?? "session model"} · ${profile.thinking}`;
     },
     issues: state.issues,
+    pulls: state.pulls,
+    reviews: state.reviews,
+    knowledge: state.knowledge,
+    excalidraw: state.excalidraw,
+    checkExcalidraw: (session) => checkSession(session.link, session.name),
+    editText: (title, text) => editText(state, title, text),
     profileLabel: (kind) => {
       const profile = lobbyProfile(state, kind);
       return `${profile.model ?? "session model"} · ${profile.thinking}`;
     },
+    workspace: () => state.workspace,
+    refreshWorkspace: () => refreshWorkspace(state),
     sessionName: () => state.pi.getSessionName(),
     sessions: () => backgroundSessions(),
     startSession: (start) => startSession(state, start),
@@ -588,20 +658,20 @@ function host(state: Runtime, tui: TUI): LobbyHost {
 }
 
 /**
- * bot-lobby's settings (or one agent's entry) from inside the lobby. The
- * lobby stays aside for the whole visit, not only for each menu, so it does
- * not flash between them, and rereads the config when it comes back.
+ * Run something pi draws itself (its settings menus, its multi-line editor)
+ * with the lobby stepped aside for the whole visit, not only for each dialog,
+ * so it does not flash between them; the lobby rereads the config after.
  */
-async function lobbySettings(state: Runtime, entry?: "quickfix" | "planner"): Promise<void> {
-  if (state.inSettings) return;
+async function whileAside<T>(state: Runtime, run: () => Promise<T>, failure: string): Promise<T | undefined> {
+  if (state.inSettings) return undefined;
   state.inSettings = true;
   setMouse(state, false);
   state.handle?.setHidden(true);
   try {
-    if (entry) await openEntrySettings(state.pi, state.ctx, entry);
-    else await openSettings(state.pi, state.ctx);
+    return await run();
   } catch (error) {
-    state.ctx.ui.notify(`bot-lobby: settings failed — ${(error as Error).message}`, "warning");
+    state.ctx.ui.notify(`bot-lobby: ${failure} — ${(error as Error).message}`, "warning");
+    return undefined;
   } finally {
     state.inSettings = false;
     state.asideForPrompt = false;
@@ -615,6 +685,16 @@ async function lobbySettings(state: Runtime, entry?: "quickfix" | "planner"): Pr
   }
 }
 
+/** bot-lobby's settings (or one agent's entry) from inside the lobby. */
+async function lobbySettings(state: Runtime, entry?: "quickfix" | "planner"): Promise<void> {
+  await whileAside(state, () => (entry ? openEntrySettings(state.pi, state.ctx, entry) : openSettings(state.pi, state.ctx)), "settings failed");
+}
+
+/** A text edited in pi's multi-line editor (Enter saves, Shift+Enter is a new line); undefined when cancelled. */
+async function editText(state: Runtime, title: string, text: string): Promise<string | undefined> {
+  return whileAside(state, () => state.ctx.ui.editor(title, text), "the editor failed");
+}
+
 /** Remember which panes show, keeping every other setting as the file has it now. */
 function savePanels(panels: Record<LobbyPanel, boolean>): void {
   try {
@@ -718,6 +798,7 @@ function shutdown(): void {
   setMouse(state, false);
   state.unsubscribeFeed?.();
   state.quickfix.cancelAll();
+  state.reviews.cancelAll();
   state.planner?.cancel();
   state.view?.dispose();
   state.handle?.hide();
@@ -759,9 +840,36 @@ export function initLobby(pi: ExtensionAPI, ctx: ExtensionContext, configDir: st
     asking: false,
     mouse: false,
     inSettings: false,
+    workspace: { name: basename(ctx.cwd) || ctx.cwd },
+    readingWorkspace: false,
     quickfix: undefined as unknown as QuickFixQueue,
     issues: new IssuesState(execCommand, ctx.cwd, rerender),
+    pulls: new PullsState(execCommand, ctx.cwd, rerender),
+    reviews: undefined as unknown as PullReviews,
+    knowledge: new KnowledgeBook({
+      root,
+      configDir,
+      threshold: () => loadConfig().knowledge.compactionThreshold,
+      backups: () => loadConfig().knowledge.backupCount,
+      sessionId: () => ctx.sessionManager.getSessionId(),
+    }),
+    excalidraw: new ExcalidrawBook({ root }),
   };
+  state.reviews = new PullReviews({
+    cwd: ctx.cwd,
+    root,
+    configDir,
+    exec: execCommand,
+    profile: () => reviewProfile(state),
+    stallTimeoutMs: workflow.stallTimeoutMs,
+    toolStallTimeoutMs: workflow.toolStallTimeoutMs,
+    feed: lobbyFeed,
+    onChange: rerender,
+    notify: (message, level) => {
+      if (!state.visible) ctx.ui.notify(message, level);
+    },
+    classifier: classifier(),
+  });
   state.quickfix = new QuickFixQueue({
     cwd: ctx.cwd,
     root,

package/src/lobby/split.ts

@@ -0,0 +1,230 @@
+/**
+ * Splitting a long plan into tasks. When the user saves a plan with many
+ * steps, the oracle proposes how to cut it into two to five tasks, the user
+ * decides (keep it whole, take the split, or say what to change), and each part
+ * is saved as a pending task that knows its siblings.
+ *
+ * The oracle decides where the lines go; the engine enforces the rest: at
+ * most `MAX_SPLIT_TASKS` tasks, every step of the plan in exactly one of them,
+ * and a task only ever building on earlier ones. A proposal that breaks a rule
+ * is sent back once with the problems, and never reaches the user. Each part's
+ * brief is composed here from the plan as written (its objective, decisions,
+ * assumptions and risks stay whole, its steps section holds only that part's
+ * steps), so nothing the user agreed can be lost in a model's retelling.
+ */
+import { loadPrompt } from "../prompts/loader.ts";
+import { planStepBlocks } from "../pi/plan-checklist.ts";
+import type { SplitInfo } from "../state/backlog.ts";
+import type { AskQuestion } from "../ask/types.ts";
+
+/** The most tasks a plan is split into. */
+export const MAX_SPLIT_TASKS = 5;
+/** Times the user may ask the oracle to change a split before it is final. */
+export const MAX_SPLIT_REVISIONS = 3;
+
+export interface SplitTask {
+  title: string;
+  goal: string;
+  /** The plan's steps (numbered from 1) this task does. */
+  covers: number[];
+  /** Earlier tasks (numbered from 1) it builds on. */
+  after: number[];
+  done: string[];
+}
+
+export interface SplitProposal {
+  tasks: SplitTask[];
+  /** What the oracle tells the user about the split. */
+  note?: string;
+}
+
+export function splitPrompt(instructions?: string): string {
+  const custom = instructions?.trim();
+  return custom ? `${loadPrompt("splitter.md")}\n\n## Custom Instructions\n\n${custom}` : loadPrompt("splitter.md");
+}
+
+/** `3, 5-6` as [3, 5, 6]; `none` (or nothing) as []. Ranges are bounded, so a stray `1-999999` cannot fill memory. */
+export function parseNumbers(text: string): number[] {
+  const found = new Set<number>();
+  for (const match of text.matchAll(/(\d+)(?:\s*[-–—]\s*(\d+))?/g)) {
+    const first = Number(match[1]);
+    const last = match[2] ? Number(match[2]) : first;
+    for (let number = first; number <= Math.min(last, first + 200); number += 1) found.add(number);
+  }
+  return [...found].sort((a, b) => a - b);
+}
+
+/** Read the oracle's reply into a proposal; throws a one-line reason when it has no tasks at all. */
+export function parseSplit(text: string): SplitProposal {
+  const [head = "", ...after] = text.split(/^##\s+Note\s*$/im);
+  const note = after.join("\n").trim().replace(/\s+/g, " ") || undefined;
+  const parts = head.split(/^###\s+\d+[.):]?\s*/m).slice(1);
+  if (parts.length === 0) throw new Error("no tasks found: write each as `### 1. Title` with Goal, Covers, After and Done when");
+  const tasks = parts.map((part): SplitTask => {
+    const lines = part.split("\n");
+    const title = (lines[0] ?? "").replace(/[*_`#]/g, "").trim();
+    const value = (key: string) => new RegExp(`^\\s*[-*]?\\s*\\**${key}\\**\\s*:\\**\\s*(.*)$`, "im").exec(part)?.[1]?.trim() ?? "";
+    const doneAt = lines.findIndex((line) => /^\s*\**done when\**\s*:/i.test(line));
+    const inline = doneAt < 0 ? undefined : /:\**\s*(\S.*)$/.exec(lines[doneAt]!)?.[1];
+    const bullets = doneAt < 0 ? [] : lines.slice(doneAt + 1).filter((line) => /^\s*[-*]\s+\S/.test(line)).map((line) => line.replace(/^\s*[-*]\s+/, "").trim());
+    const done = [...(inline ? [inline] : []), ...bullets];
+    return { title, goal: value("goal"), covers: parseNumbers(value("covers")), after: parseNumbers(value("after")), done };
+  });
+  return { tasks, ...(note ? { note } : {}) };
+}
+
+/** Every rule a proposal breaks, in words the oracle can act on; empty when it is sound. */
+export function splitProblems(proposal: SplitProposal, stepCount: number, max = MAX_SPLIT_TASKS): string[] {
+  const problems: string[] = [];
+  const { tasks } = proposal;
+  if (tasks.length < 2) problems.push("a split needs at least 2 tasks");
+  if (tasks.length > max) problems.push(`a plan is split into at most ${max} tasks, not ${tasks.length}`);
+  const owner = new Map<number, number>();
+  tasks.forEach((task, index) => {
+    const number = index + 1;
+    if (!task.title) problems.push(`task ${number} has no title`);
+    if (task.covers.length === 0) problems.push(`task ${number} covers no steps`);
+    for (const step of task.covers) {
+      if (step < 1 || step > stepCount) problems.push(`task ${number} covers step ${step}, but the plan has steps 1 to ${stepCount}`);
+      else if (owner.has(step)) problems.push(`step ${step} is in both task ${owner.get(step)} and task ${number}`);
+      else owner.set(step, number);
+    }
+    for (const earlier of task.after) if (earlier >= number || earlier < 1) problems.push(`task ${number} cannot come after task ${earlier}: list the tasks in the order they can be done, each building only on earlier ones`);
+  });
+  const missing = Array.from({ length: stepCount }, (_, index) => index + 1).filter((step) => !owner.has(step));
+  if (missing.length > 0) problems.push(`step${missing.length === 1 ? "" : "s"} ${missing.join(", ")} ${missing.length === 1 ? "is" : "are"} in no task: every step belongs to exactly one`);
+  return [...new Set(problems)];
+}
+
+/** `1-3, 5` for step numbers. */
+export function rangeWords(numbers: readonly number[]): string {
+  const parts: string[] = [];
+  for (let index = 0; index < numbers.length; ) {
+    let end = index;
+    while (end + 1 < numbers.length && numbers[end + 1] === numbers[end]! + 1) end += 1;
+    parts.push(end > index ? `${numbers[index]}-${numbers[end]}` : String(numbers[index]));
+    index = end + 1;
+  }
+  return parts.join(", ");
+}
+
+/** What the oracle is asked: the plan, its steps as numbered here, and, on a revision, the split so far with what the user wants changed. */
+export function splitRequest(input: { title: string; plan: string; steps: readonly string[]; max?: number; revision?: { previous: SplitProposal; words: string }; rejected?: readonly string[] }): string {
+  const max = input.max ?? MAX_SPLIT_TASKS;
+  const lines = [
+    `Split this plan into 2 to ${max} tasks: ${input.title}`,
+    "",
+    `The plan has ${input.steps.length} steps. They are numbered here in the order of its Steps section; use these numbers in Covers.`,
+    ...input.steps.map((step, index) => `${index + 1}. ${step.replace(/\s+/g, " ").trim()}`),
+    "",
+    "## The plan",
+    "",
+    input.plan.trim(),
+  ];
+  if (input.revision) {
+    lines.push("", "## The split so far", "", proposalText(input.revision.previous), "", `## What the user wants changed`, "", input.revision.words.trim(), "", "Apply exactly that and keep the rest of the split as it is.");
+  }
+  if (input.rejected && input.rejected.length > 0) {
+    lines.push("", "## Your last split was rejected", "", ...input.rejected.map((problem) => `- ${problem}`), "", "Answer again in the required format with a split that breaks none of these.");
+  }
+  return lines.join("\n");
+}
+
+/** A proposal as the oracle's own format, so a revision starts from what it (and the user) saw. */
+export function proposalText(proposal: SplitProposal): string {
+  return [
+    "## Tasks",
+    ...proposal.tasks.flatMap((task, index) => [
+      `### ${index + 1}. ${task.title}`,
+      `Goal: ${task.goal}`,
+      `Covers: ${rangeWords(task.covers)}`,
+      `After: ${task.after.length > 0 ? rangeWords(task.after) : "none"}`,
+      ...(task.done.length > 0 ? ["Done when:", ...task.done.map((point) => `- ${point}`)] : []),
+      "",
+    ]),
+    ...(proposal.note ? ["## Note", proposal.note] : []),
+  ].join("\n").trimEnd();
+}
+
+/** Markdown for the questionnaire's preview: each task with the steps it takes. */
+export function splitPreview(proposal: SplitProposal, steps: readonly string[]): string {
+  const clip = (text: string) => {
+    const flat = text.replace(/\s+/g, " ").trim();
+    return flat.length > 110 ? `${flat.slice(0, 109)}…` : flat;
+  };
+  return proposal.tasks.map((task, index) => [
+    `**${index + 1}. ${task.title}** · step${task.covers.length === 1 ? "" : "s"} ${rangeWords(task.covers)}${task.after.length > 0 ? ` · after ${rangeWords(task.after)}` : ""}`,
+    ...(task.goal ? [`_${clip(task.goal)}_`] : []),
+    ...task.covers.map((step) => `- ${step}. ${clip(steps[step - 1] ?? "")}`),
+  ].join("\n")).join("\n\n");
+}
+
+/** The question the user answers: take the split, keep the plan whole, or write what to change. */
+export function splitQuestion(input: { stepCount: number; proposal: SplitProposal; steps: readonly string[]; revisions: number }): AskQuestion {
+  const count = input.proposal.tasks.length;
+  const last = input.revisions >= MAX_SPLIT_REVISIONS;
+  return {
+    header: "Split plan",
+    question: [
+      `This plan has **${input.stepCount} steps**. The oracle suggests splitting it into **${count} tasks**, each finished and reviewed on its own.`,
+      ...(input.proposal.note ? [input.proposal.note] : []),
+      last ? "This is the last revision: take it, or keep the plan whole." : "Type what to change (for example *merge 2 and 3*) to revise it.",
+    ].join("\n\n"),
+    options: [
+      { label: `${splitLabel(count)} (Recommended)`, description: "Each part is saved as its own pending task, in order, knowing the others.", preview: splitPreview(input.proposal, input.steps) },
+      { label: "Keep it as one task", description: `One task with all ${input.stepCount} steps.` },
+    ],
+  };
+}
+
+export const KEEP_WHOLE = "Keep it as one task";
+
+export function splitLabel(count: number): string {
+  return `Split into ${count} tasks`;
+}
+
+/** Ask whether to save a plan as one task after the oracle could not split it. */
+export function splitFailedQuestion(reason: string): AskQuestion {
+  return {
+    header: "Split plan",
+    question: `The oracle could not split this plan (${reason.replace(/\s+/g, " ").trim()}). Save it as one task?`,
+    options: [
+      { label: "Save it as one task", description: "All the steps in one pending task." },
+      { label: "Not now", description: "Save nothing; ctrl+s asks again." },
+    ],
+  };
+}
+
+/** The original plan with its Steps section holding only `covers` (renumbered); undefined when the plan's steps are not a list. */
+function planWithSteps(plan: string, covers: readonly number[], stepCount: number): string | undefined {
+  const found = planStepBlocks(plan);
+  if (!found || found.blocks.length !== stepCount) return undefined;
+  const lines = plan.split("\n");
+  const kept = covers.map((step, index) => found.blocks[step - 1]!.replace(/^(\s*)\d+([.)])/, (_all, indent: string, mark: string) => `${indent}${index + 1}${mark}`));
+  const spacer = found.to > found.from && !(lines[found.to - 1] ?? "").trim() ? [""] : [];
+  return [...lines.slice(0, found.from), ...kept.flatMap((block) => block.split("\n")), ...spacer, ...lines.slice(found.to)].join("\n");
+}
+
+/** One part's brief: where it sits, what it delivers, then the plan as written with only its own steps. */
+export function partBrief(input: { plan: string; steps: readonly string[]; proposal: SplitProposal; index: number }): string {
+  const { proposal, index } = input;
+  const task = proposal.tasks[index]!;
+  const of = proposal.tasks.length;
+  const head = [
+    `### Part ${index + 1} of ${of} — ${task.title}`,
+    ...(task.goal ? [`**Goal of this part:** ${task.goal}`] : []),
+    ...(task.after.length > 0 ? [`**Builds on:** ${task.after.map((part) => `part ${part} — ${proposal.tasks[part - 1]?.title ?? ""}`).join("; ")} (finish that first).`] : []),
+    ...(task.done.length > 0 ? ["**Done when:**", ...task.done.map((point) => `- ${point}`)] : []),
+  ].join("\n");
+  const own = planWithSteps(input.plan, task.covers, input.steps.length);
+  if (own) return `${head}\n\n${own.trim()}`;
+  // Steps that are not a list: the whole plan, with this part's steps named on top.
+  const named = task.covers.map((step, position) => `${position + 1}. ${(input.steps[step - 1] ?? "").replace(/\s+/g, " ").trim()}`);
+  return `${head}\n\n**Steps of this part (do only these; the plan below is the whole plan, for context):**\n${named.join("\n")}\n\n${input.plan.trim()}`;
+}
+
+/** What each saved part knows of the others. */
+export function partInfo(proposal: SplitProposal, index: number, group: string): SplitInfo {
+  const task = proposal.tasks[index]!;
+  return { group, part: index + 1, of: proposal.tasks.length, titles: proposal.tasks.map((entry) => entry.title), after: [...task.after] };
+}

package/src/lobby/tabs/excalidraw.ts

@@ -0,0 +1,95 @@
+/**
+ * The Excalidraw tab: the shared sessions the user has added (five at most),
+ * on the left, and the picked one on the right — its link, whether agents may
+ * draw in it, the last check of it, and every agent it can be assigned to as a
+ * checklist. Assigned agents get the Excalidraw tools and join the room under
+ * their own name.
+ */
+import { AGENT_LABELS, EXCALIDRAW_AGENTS, MAX_SESSIONS, type ExcalidrawSession } from "../../excalidraw/sessions.ts";
+import { bold, columns, fill, paint, rule, selectRow, spinner, split, spread, windowStart, wrap, type LobbyTheme } from "../layout.ts";
+
+/** What the last check of a session found. */
+export interface SessionCheck {
+  ok: boolean;
+  text: string;
+}
+
+export interface ExcalidrawTabInput {
+  sessions: readonly ExcalidrawSession[];
+  selected: number;
+  focus: "list" | "detail";
+  /** The agent under the cursor in the checklist. */
+  agent: number;
+  checks: ReadonlyMap<string, SessionCheck>;
+  /** Ids of the sessions being checked now. */
+  checking: ReadonlySet<string>;
+  tick: number;
+}
+
+export const EXCALIDRAW_COLUMNS_MIN = 90;
+
+function agentCount(session: ExcalidrawSession): string {
+  const count = session.agents.length;
+  return count === 0 ? "no agents" : `${count} agent${count === 1 ? "" : "s"}`;
+}
+
+/** The sessions, the selected one in view. */
+export function sessionRows(input: ExcalidrawTabInput, width: number, height: number, theme?: LobbyTheme): string[] {
+  const rows = input.sessions.map((session, index) => {
+    const selected = index === input.selected;
+    const mark = input.checking.has(session.id) ? paint(theme, "accent", spinner(input.tick)) : input.checks.get(session.id)?.ok === false ? paint(theme, "warning", "!") : input.checks.has(session.id) ? paint(theme, "success", "✓") : " ";
+    const facts = paint(theme, session.agents.length > 0 ? "accent" : "dim", agentCount(session));
+    return selectRow(theme, spread(`${mark} ${selected ? bold(theme, session.name) : session.name}`, facts, width - 2), width, selected, input.focus === "list");
+  });
+  return rows.slice(windowStart(input.selected, rows.length, height), windowStart(input.selected, rows.length, height) + height);
+}
+
+function emptyLines(width: number, theme?: LobbyTheme): string[] {
+  return [
+    ...wrap(paint(theme, "dim", "No sessions yet. A session is a live Excalidraw room that you and your agents draw in together."), width),
+    "",
+    ...wrap(`${paint(theme, "accent", "a")}  add one: in Excalidraw, Share → Live collaboration → Start session, then paste the link`, width),
+    ...wrap(`${paint(theme, "accent", "n")}  or make a new room here and open its link in Excalidraw`, width),
+    "",
+    ...wrap(paint(theme, "dim", `Up to ${MAX_SESSIONS} sessions; each can be assigned to one agent or several.`), width),
+  ];
+}
+
+/** The picked session: its link and state, then the agents it can be assigned to. */
+export function detailLines(input: ExcalidrawTabInput, width: number, theme?: LobbyTheme): string[] {
+  const session = input.sessions[input.selected];
+  if (!session) return [];
+  const lines: string[] = [];
+  lines.push(...wrap(paint(theme, "muted", session.link), width));
+  lines.push(paint(theme, session.contribute ? "success" : "warning", session.contribute ? "agents may draw here (w: look only)" : "agents may only look (w: let them draw)"));
+  const check = input.checks.get(session.id);
+  if (input.checking.has(session.id)) lines.push(paint(theme, "accent", `${spinner(input.tick)} checking the room…`));
+  else if (check) lines.push(...wrap(paint(theme, check.ok ? "success" : "warning", `${check.ok ? "✓" : "!"} ${check.text}`), width));
+  else lines.push(paint(theme, "dim", "t checks that the room can be reached"));
+  lines.push("", rule(width, "Assigned to", theme, agentCount(session)));
+  EXCALIDRAW_AGENTS.forEach((agent, index) => {
+    const on = session.agents.includes(agent);
+    const picked = input.focus === "detail" && index === input.agent;
+    const box = on ? paint(theme, "success", "[x]") : paint(theme, "dim", "[ ]");
+    const cursor = picked ? paint(theme, "accent", "▸") : " ";
+    const label = on ? AGENT_LABELS[agent] : paint(theme, "muted", AGENT_LABELS[agent]);
+    lines.push(selectRow(theme, `${cursor} ${box} ${picked ? bold(theme, label) : label}`, width, picked, true));
+  });
+  lines.push("", ...wrap(paint(theme, "dim", "Assigned agents read the board and draw on it with excalidraw_read and excalidraw_draw, and appear in the room under their own name."), width));
+  return lines;
+}
+
+export function renderExcalidraw(input: ExcalidrawTabInput, width: number, height: number, theme?: LobbyTheme): string[] {
+  if (height <= 0) return [];
+  const count = `${input.sessions.length}/${MAX_SESSIONS}`;
+  if (input.sessions.length === 0) return fill([rule(width, "Excalidraw", theme, count), ...emptyLines(width, theme)], height, width);
+  const selected = Math.min(Math.max(0, input.selected), input.sessions.length - 1);
+  const view = { ...input, selected };
+  const wide = width >= EXCALIDRAW_COLUMNS_MIN;
+  const [listWidth, detailWidth] = wide ? split(width, 0.34, 3, 44) : [width, width];
+  const listPane = fill([rule(listWidth, "Sessions", theme, count), ...sessionRows(view, listWidth, height - 1, theme)], height);
+  const session = input.sessions[selected]!;
+  const detailPane = fill([rule(detailWidth, `${session.name}${input.focus === "detail" ? " ◂" : ""}`, theme), ...detailLines(view, detailWidth, theme)], height);
+  if (!wide) return fill(input.focus === "detail" ? detailPane : listPane, height, width);
+  return fill(columns(listPane, detailPane, listWidth, detailWidth, " │ ", theme), height, width);
+}