@a-t-h-i/bot-lobby 0.6.6 → 0.6.8

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,10 +37,14 @@ 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 { QuickFixQueue } from "./quickfix.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 { 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";
@@ -60,6 +67,9 @@ interface Runtime {
   quickfix: QuickFixQueue;
   planner?: PlanningSession;
   issues: IssuesState;
+  pulls: PullsState;
+  reviews: PullReviews;
+  knowledge: KnowledgeBook;
   unsubscribeFeed?: () => void;
   /** Puts the panel's questions to the user: the questionnaire unless a test sets another. */
   asker?: Asker;
@@ -69,6 +79,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;
@@ -94,18 +107,39 @@ let frameTimer: ReturnType<typeof setTimeout> | undefined;
  * through pi.
  */
 function rerender(): void {
-  if (!runtime?.visible || frameTimer) return;
+  // Hidden, only the one-line status under the editor changes.
+  if (!runtime || (!runtime.visible && !miniShown(runtime)) || frameTimer) return;
   const wait = lastFrame + FRAME_MS - Date.now();
   const paint = () => {
     frameTimer = undefined;
     lastFrame = Date.now();
-    if (runtime?.visible) runtime.tui?.requestRender();
+    if (runtime?.visible || (runtime && miniShown(runtime))) runtime.tui?.requestRender();
   };
   if (wait <= 0) return paint();
   frameTimer = setTimeout(paint, wait);
   frameTimer.unref?.();
 }
 
+/** The status line shows under the editor while the lobby is hidden (not while bot-lobby is minimized), unless settings turn it off. */
+function miniShown(state: Runtime): boolean {
+  return !state.visible && !isMinimized() && loadConfig().lobby.miniLine;
+}
+
+/** What the status line shows: the task, the planning round, the quick fix in hand. */
+function miniInput(state: Runtime): MiniInput {
+  const snapshot = taskSnapshot();
+  const planner = state.planner;
+  const job = state.quickfix.running ?? state.quickfix.jobs.find((entry) => entry.status === "queued");
+  const queued = state.quickfix.jobs.filter((entry) => entry.status === "queued" && entry !== job).length;
+  return {
+    ...(snapshot.task ? { task: snapshot.task } : {}),
+    runs: snapshot.runs,
+    ...(planner ? { planning: { busy: planner.busy, round: planner.turns, limit: loadConfig().lobby.maxPlanningRounds, questions: planner.awaitingAnswers ? planner.questions.length : 0, ready: planner.reply?.status === "ready", saved: Boolean(planner.saved) } } : {}),
+    ...(job ? { quickfix: { title: jobTitle(job), running: job.status === "running", queued } } : {}),
+    key: "Alt+L",
+  };
+}
+
 function sessionModel(ctx: ExtensionContext): string | undefined {
   return ctx.model ? modelRef(ctx.model) : undefined;
 }
@@ -243,7 +277,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");
@@ -423,6 +458,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),
@@ -463,6 +507,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.
@@ -492,7 +556,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}`;
@@ -502,6 +566,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,
@@ -528,6 +608,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,
@@ -540,10 +621,16 @@ 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,
+    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),
@@ -566,20 +653,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;
@@ -593,6 +680,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 {
@@ -696,6 +793,7 @@ function shutdown(): void {
   setMouse(state, false);
   state.unsubscribeFeed?.();
   state.quickfix.cancelAll();
+  state.reviews.cancelAll();
   state.planner?.cancel();
   state.view?.dispose();
   state.handle?.hide();
@@ -737,9 +835,35 @@ 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(),
+    }),
   };
+  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,
@@ -769,7 +893,8 @@ export function initLobby(pi: ExtensionAPI, ctx: ExtensionContext, configDir: st
   // Capture pi's TUI through a zero-line widget below the editor.
   ctx.ui.setWidget(ANCHOR_KEY, (tui) => {
     state.tui = tui;
-    return { render: () => [], invalidate: () => {} };
+    // Zero lines while the lobby is up (or bot-lobby is minimized); one status line when it is hidden.
+    return { render: (width: number) => (miniShown(state) ? [miniLine(miniInput(state), width, lobbyTheme(state.ctx.ui.theme))] : []), invalidate: () => {} };
   }, { placement: "belowEditor" });
   // The owner's clock (pi/owner.ts) delivers comments and messages and drives auto mode; the lobby logs what it did.
   onOwnerEvent((event) => {

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] };
+}