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

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/git.ts

@@ -0,0 +1,162 @@
+/**
+ * The Git tab: the repository's open pull requests through `gh`, the selected
+ * one with its checks, files, description and discussion, and — the point of
+ * the tab — a review of it by a read-only agent (v, or f with a focus), or a
+ * quick read by Jev (t), shown right under its facts.
+ */
+import { textWidth } from "../../width.ts";
+import type { PullDetail, PullSummary } from "../pulls.ts";
+import { isStale, type PullReadState, type PullReview, type Verdict } from "../pr-review.ts";
+import { BRANCH_GLYPH, bold, columns, fill, markdownLines, paint, rule, selectRow, since, spinner, split, spread, windowStart, wrap, wrapHanging, type LobbyTheme } from "../layout.ts";
+
+export interface GitTabInput {
+  pulls: readonly PullSummary[];
+  selected: number;
+  detail?: PullDetail;
+  /** The agent's review of the selected pull request, and Jev's read of it. */
+  review?: PullReview;
+  read?: PullReadState;
+  focus: "list" | "detail";
+  detailOffset: number;
+  loading: boolean;
+  loaded: boolean;
+  error?: string;
+  tick: number;
+  now: number;
+}
+
+export const GIT_COLUMNS_MIN = 90;
+
+const VERDICTS: Record<Verdict, { words: string; color: "success" | "error" | "warning" }> = {
+  approve: { words: "approve", color: "success" },
+  changes: { words: "request changes", color: "error" },
+  comment: { words: "comment", color: "warning" },
+};
+
+/** `✓` passing, `✗` failing, `●` still running, blank without checks. */
+function checkMark(pull: PullSummary, theme?: LobbyTheme): string {
+  if (pull.checks === "passing") return paint(theme, "success", "✓");
+  if (pull.checks === "failing") return paint(theme, "error", "✗");
+  if (pull.checks === "pending") return paint(theme, "warning", "●");
+  return " ";
+}
+
+/** The size of a change, `+12 −3`, added lines green and removed ones red. */
+export function changeSize(additions: number, deletions: number, theme?: LobbyTheme): string {
+  return `${paint(theme, "success", `+${additions}`)} ${paint(theme, "error", `−${deletions}`)}`;
+}
+
+function decisionWords(decision: string | undefined): { words: string; color: "success" | "error" | "warning" } | undefined {
+  if (decision === "APPROVED") return { words: "approved", color: "success" };
+  if (decision === "CHANGES_REQUESTED") return { words: "changes requested", color: "error" };
+  if (decision === "REVIEW_REQUIRED") return { words: "review required", color: "warning" };
+  return undefined;
+}
+
+/** How long a review took, `2m 05s`. */
+function took(review: PullReview, now: number): string {
+  const ms = Math.max(0, (review.finishedAt ?? now) - review.startedAt);
+  const seconds = Math.round(ms / 1000);
+  return seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m ${String(seconds % 60).padStart(2, "0")}s`;
+}
+
+/** The review of the selected pull request: running steps, or the finished review, or why it failed. */
+export function reviewLines(review: PullReview, detail: PullDetail | undefined, width: number, tick: number, now: number, theme?: LobbyTheme): string[] {
+  const lines: string[] = [];
+  const verdict = review.verdict ? VERDICTS[review.verdict] : undefined;
+  // Short enough to fit beside the title in a narrow pane; the model goes on a line of its own.
+  const right = review.status === "running"
+    ? `${spinner(tick)} ${took(review, now)}`
+    : [verdict ? paint(theme, verdict.color, verdict.words) : "", review.status === "done" ? took(review, now) : review.status].filter(Boolean).join(paint(theme, "dim", " · "));
+  lines.push(rule(width, "Review", theme, right));
+  if (review.model) lines.push(paint(theme, "dim", [review.model, review.thinking].filter(Boolean).join(" · ")));
+  if (review.focus) lines.push(...wrapHanging(paint(theme, "dim", "focus: "), review.focus, width));
+  if (review.saved) lines.push(paint(theme, "dim", `kept from ${since(now - review.startedAt)}`));
+  if (isStale(review, detail)) lines.push(paint(theme, "warning", "the pull request has new commits since this review — v reviews it again"));
+  if (review.status === "running") {
+    for (const step of review.steps.slice(-6)) lines.push(...wrapHanging(paint(theme, "dim", "· "), paint(theme, "muted", step), width));
+    lines.push(paint(theme, "dim", "x stops it"));
+    return lines;
+  }
+  if (review.status === "cancelled") lines.push(paint(theme, "warning", "stopped"));
+  if (review.status === "failed" || review.status === "timeout") lines.push(...wrap(paint(theme, "error", `✗ ${review.error ?? review.status}`), width));
+  if (review.text) lines.push(...markdownLines(review.text, width, theme));
+  return lines;
+}
+
+/** Jev's read: one line, or the reason there is none. */
+export function readLines(read: PullReadState, width: number, tick: number, theme?: LobbyTheme): string[] {
+  if (read.status === "running") return [rule(width, "Jev's read", theme, spinner(tick)), paint(theme, "dim", "reading the diff…")];
+  if (read.status === "failed") return [rule(width, "Jev's read", theme), ...wrap(paint(theme, "warning", read.error ?? "Jev could not read it"), width)];
+  return [rule(width, "Jev's read", theme, read.read ? `${read.read.model} · ${read.read.ms} ms` : ""), ...wrap(read.line ?? "", width)];
+}
+
+export function pullDetailLines(pull: PullDetail, review: PullReview | undefined, read: PullReadState | undefined, width: number, tick: number, now: number, theme?: LobbyTheme): string[] {
+  const dot = paint(theme, "dim", " · ");
+  const decision = decisionWords(pull.decision);
+  const facts = [
+    pull.state ? paint(theme, pull.state === "OPEN" ? "success" : "dim", pull.draft ? "draft" : pull.state.toLowerCase()) : pull.draft ? paint(theme, "dim", "draft") : "",
+    pull.author ? `by ${pull.author}` : "",
+    pull.updatedAt ? `updated ${since(now - Date.parse(pull.updatedAt))}` : "",
+  ].filter(Boolean);
+  const checks = pull.checks ? `checks ${paint(theme, pull.checks === "passing" ? "success" : pull.checks === "failing" ? "error" : "warning", pull.checks)} (${pull.checkCount})` : "";
+  const merge = pull.mergeable ? (pull.mergeable === "CONFLICTING" ? paint(theme, "error", "conflicts") : pull.mergeable === "MERGEABLE" ? "mergeable" : "") : "";
+  const lines = [
+    ...wrap(bold(theme, `#${pull.number} ${pull.title}`), width),
+    facts.join(dot),
+    `${paint(theme, "accent", `${BRANCH_GLYPH} ${pull.headRef || "?"}`)} → ${pull.baseRef || "?"}${dot}${changeSize(pull.additions, pull.deletions, theme)}${dot}${pull.changedFiles} file${pull.changedFiles === 1 ? "" : "s"}`,
+    [checks, decision ? paint(theme, decision.color, decision.words) : "", merge, pull.labels.length > 0 ? paint(theme, "warning", pull.labels.join(", ")) : ""].filter(Boolean).join(dot),
+  ].filter((line) => line.length > 0);
+  if (pull.url) lines.push(paint(theme, "dim", pull.url));
+  lines.push("", ...wrap(paint(theme, "dim", "v reviews it with an agent · f with a focus you type · t is Jev's quick read"), width));
+  if (read) lines.push("", ...readLines(read, width, tick, theme));
+  if (review) lines.push("", ...reviewLines(review, pull, width, tick, now, theme));
+  if (pull.files.length > 0) {
+    lines.push("", rule(width, "Files", theme, String(pull.files.length)));
+    const numbers = pull.files.map((file) => textWidth(changeSize(file.additions, file.deletions)));
+    const room = Math.max(...numbers);
+    for (const file of pull.files) lines.push(spread(file.path, `${" ".repeat(room - textWidth(changeSize(file.additions, file.deletions)))}${changeSize(file.additions, file.deletions, theme)}`, width));
+  }
+  lines.push("", rule(width, "Description", theme), ...(pull.body.trim() ? markdownLines(pull.body.trim(), width, theme) : [paint(theme, "dim", "(no description)")]));
+  for (const note of pull.notes) {
+    const verdict = note.state && note.state !== "COMMENTED" ? paint(theme, note.state === "APPROVED" ? "success" : note.state === "CHANGES_REQUESTED" ? "error" : "warning", note.state.toLowerCase().replace(/_/g, " ")) : "";
+    lines.push("", rule(width, note.author ?? "comment", theme, [verdict, note.at ? since(now - Date.parse(note.at)) : ""].filter(Boolean).join(" · ")), ...(note.body.trim() ? markdownLines(note.body.trim(), width, theme) : []));
+  }
+  return lines;
+}
+
+function empty(input: GitTabInput, width: number, theme?: LobbyTheme): string[] {
+  if (input.loading) return [`${paint(theme, "accent", spinner(input.tick))} loading pull requests from GitHub…`];
+  if (input.error) return [];
+  if (!input.loaded) return wrap(paint(theme, "dim", "Press r to load open pull requests with the GitHub CLI (gh)."), width);
+  return wrap(paint(theme, "dim", "No open pull requests."), width);
+}
+
+/** One row of the list: number, checks, title, and the review's outcome when there is one. */
+function row(pull: PullSummary, width: number, selected: boolean, focused: boolean, review: PullReview | undefined, theme?: LobbyTheme): string {
+  const verdict = review?.status === "done" && review.verdict ? paint(theme, VERDICTS[review.verdict].color, review.verdict === "approve" ? "✓ reviewed" : review.verdict === "changes" ? "✗ reviewed" : "◆ reviewed") : review?.status === "running" ? paint(theme, "accent", "reviewing") : "";
+  const title = selected ? bold(theme, pull.title) : pull.title;
+  const draft = pull.draft ? `${paint(theme, "dim", "draft")} ` : "";
+  const head = `${paint(theme, "dim", `#${pull.number}`)} ${checkMark(pull, theme)} ${draft}${title}`;
+  return selectRow(theme, spread(head, [verdict, changeSize(pull.additions, pull.deletions, theme)].filter(Boolean).join(" "), width), width, selected, focused);
+}
+
+export function renderGit(input: GitTabInput, width: number, height: number, theme?: LobbyTheme): string[] {
+  if (height <= 0) return [];
+  const banner = input.error ? wrap(paint(theme, "error", `✗ ${input.error}`), width) : [];
+  const bodyHeight = Math.max(0, height - banner.length);
+  if (input.pulls.length === 0) return fill([...banner, rule(width, "Pull requests", theme), ...empty(input, width, theme)], height, width);
+  const selected = Math.min(Math.max(0, input.selected), input.pulls.length - 1);
+  const wide = width >= GIT_COLUMNS_MIN;
+  const [listWidth, detailWidth] = wide ? split(width, 0.4, 3, 40) : [width, width];
+  const rows = input.pulls.map((pull, index) => row(pull, listWidth, index === selected, input.focus === "list", pull.number === input.review?.number ? input.review : undefined, theme));
+  const right = input.loading ? `${spinner(input.tick)} refreshing` : `${input.pulls.length} open`;
+  const listPane = fill([rule(listWidth, "Pull requests", theme, right), ...rows.slice(windowStart(selected, rows.length, bodyHeight - 1))], bodyHeight);
+  const current = input.pulls[selected]!;
+  const detail = input.detail && input.detail.number === current.number
+    ? pullDetailLines(input.detail, input.review, input.read, detailWidth, input.tick, input.now, theme)
+    : [`${paint(theme, "accent", spinner(input.tick))} loading #${current.number}…`];
+  const detailPane = fill([rule(detailWidth, input.focus === "detail" ? "Pull request ◂" : "Pull request", theme), ...detail.slice(Math.max(0, Math.min(input.detailOffset, detail.length - 1)))], bodyHeight);
+  if (!wide) return fill([...banner, ...(input.focus === "detail" ? detailPane : listPane)], height, width);
+  return fill([...banner, ...columns(listPane, detailPane, listWidth, detailWidth, " │ ", theme)], height, width);
+}

package/src/lobby/tabs/knowledge.ts

@@ -0,0 +1,135 @@
+/**
+ * The Knowledge tab: everything each agent knows about the project — its
+ * knowledge, standards, decisions and completed tasks — with the file on the
+ * left and its entries on the right, one of them picked. The picked entry can
+ * be edited, deleted or commented on; the notes sit right under the entries
+ * they are about, as every agent reads them.
+ */
+import type { KnowledgeNote } from "../../knowledge/notes.ts";
+import { AGENT_DIR_NAMES, type KnowledgeAgent } from "../../knowledge/paths.ts";
+import { AGENT_LABELS, type KnowledgeFileInfo, type KnowledgeView } from "../knowledge.ts";
+import { bold, columns, fill, markdownLines, paint, rule, selectRow, spread, split, windowStart, wrap, wrapHanging, type LobbyTheme } from "../layout.ts";
+
+export interface KnowledgeLayout {
+  /** The first line of the entries shown, as the last frame drew them. */
+  offset: number;
+  /** How many lines the entries take, and how many the pane shows. */
+  total: number;
+  rows: number;
+}
+
+export interface KnowledgeTabInput {
+  files: readonly KnowledgeFileInfo[];
+  selected: number;
+  /** The selected file, read. */
+  view?: KnowledgeView;
+  /** The picked entry, an index into the file's entries. */
+  cursor: number;
+  focus: "list" | "detail";
+  /** The first line to show, unless the picked entry needs another. */
+  offset: number;
+  layout: KnowledgeLayout;
+}
+
+export const KNOWLEDGE_COLUMNS_MIN = 90;
+
+/** `812`, `1.2k`, `24k`. */
+export function sizeWords(chars: number): string {
+  if (chars < 1000) return String(chars);
+  const thousands = chars / 1000;
+  return `${thousands >= 10 ? Math.round(thousands) : thousands.toFixed(1)}k`;
+}
+
+function fileRow(info: KnowledgeFileInfo, width: number, selected: boolean, focused: boolean, theme?: LobbyTheme): string {
+  const facts = [
+    info.over ? paint(theme, "warning", `${sizeWords(info.chars)} · over`) : paint(theme, "dim", sizeWords(info.chars)),
+    info.notes > 0 ? paint(theme, "accent", `✎ ${info.notes}`) : "",
+  ].filter(Boolean).join(" ");
+  return selectRow(theme, spread(selected ? bold(theme, info.label) : info.label, facts, width - 2), width, selected, focused);
+}
+
+/** The files, grouped by agent, the selected one in view. */
+export function listLines(files: readonly KnowledgeFileInfo[], selected: number, width: number, height: number, focused: boolean, theme?: LobbyTheme): string[] {
+  const lines: string[] = [];
+  let at = 0;
+  let previous: KnowledgeAgent | undefined;
+  files.forEach((info, index) => {
+    if (info.agent !== previous) {
+      previous = info.agent;
+      if (lines.length > 0) lines.push("");
+      const notes = files.filter((file) => file.agent === info.agent).reduce((total, file) => total + file.notes, 0);
+      lines.push(rule(width, AGENT_LABELS[info.agent], theme, notes > 0 ? `✎ ${notes}` : ""));
+    }
+    if (index === selected) at = lines.length;
+    lines.push(fileRow(info, width, index === selected, focused, theme));
+  });
+  return lines.slice(windowStart(at, lines.length, height));
+}
+
+/** One note under its entry. */
+function noteLines(note: KnowledgeNote, width: number, theme?: LobbyTheme, about?: string): string[] {
+  const lead = paint(theme, "accent", "  ✎ ");
+  const text = about ? `about “${about.replace(/\s+/g, " ").trim().slice(0, 50)}”: ${note.text}` : note.text;
+  return wrapHanging(lead, paint(theme, "muted", text), width);
+}
+
+/** The entries of the open file, each drawn once, with where the picked one sits. */
+export function entryLines(view: KnowledgeView, cursor: number, width: number, focused: boolean, theme?: LobbyTheme): { lines: string[]; from: number; to: number } {
+  const lines: string[] = [];
+  let from = 0;
+  let to = 0;
+  let previousEnd = 0;
+  view.entries.forEach((entry, index) => {
+    if (index > 0 && entry.start > previousEnd) lines.push("");
+    previousEnd = entry.end;
+    const picked = index === cursor;
+    const body = markdownLines(entry.text, Math.max(8, width - 2), theme);
+    if (picked) from = lines.length;
+    body.forEach((line, row) => {
+      const mark = picked ? paint(theme, "accent", row === 0 ? "▸ " : "  ") : "  ";
+      lines.push(picked ? selectRow(theme, `${mark}${line}`, width, true, focused) : `${mark}${line}`);
+    });
+    for (const note of view.attached.filter((candidate) => candidate.entry === entry.text)) lines.push(...noteLines(note, width, theme));
+    if (picked) to = lines.length;
+  });
+  if (view.detached.length > 0) {
+    lines.push("", rule(width, "Notes on entries that changed", theme, String(view.detached.length)));
+    for (const note of view.detached) lines.push(...noteLines(note, width, theme, note.entry));
+  }
+  return { lines, from, to };
+}
+
+export function renderKnowledge(input: KnowledgeTabInput, width: number, height: number, theme?: LobbyTheme): string[] {
+  if (height <= 0) return [];
+  if (input.files.length === 0) return fill([rule(width, "Knowledge", theme), ...wrap(paint(theme, "dim", "No knowledge files yet."), width)], height, width);
+  const selected = Math.min(Math.max(0, input.selected), input.files.length - 1);
+  const wide = width >= KNOWLEDGE_COLUMNS_MIN;
+  const [listWidth, detailWidth] = wide ? split(width, 0.34, 3, 44) : [width, width];
+  const total = input.files.reduce((sum, info) => sum + info.notes, 0);
+  const listPane = fill([rule(listWidth, "Knowledge", theme, total > 0 ? `✎ ${total}` : ""), ...listLines(input.files, selected, listWidth, height - 1, input.focus === "list", theme)], height);
+  const info = input.files[selected]!;
+  const view = input.view && input.view.agent === info.agent && input.view.file === info.file ? input.view : undefined;
+  const title = `${AGENT_DIR_NAMES[info.agent]} · ${info.file}${input.focus === "detail" ? " ◂" : ""}`;
+  const head: string[] = [rule(detailWidth, title, theme, view ? `${view.entries.length} entr${view.entries.length === 1 ? "y" : "ies"} · ${sizeWords(view.chars)} chars` : "")];
+  if (view?.over) head.push(...wrap(paint(theme, "warning", `over the compaction threshold — ask the oracle to compact ${info.file}`), detailWidth));
+  const rows = Math.max(1, height - head.length);
+  let body: string[];
+  if (!view) body = [paint(theme, "dim", "reading…")];
+  else if (view.entries.length === 0 && view.detached.length === 0) body = wrap(paint(theme, "dim", "Nothing here yet. n adds the first entry."), detailWidth);
+  else {
+    const drawn = entryLines(view, Math.min(input.cursor, Math.max(0, view.entries.length - 1)), detailWidth, input.focus === "detail", theme);
+    let start = Math.max(0, Math.min(input.offset, Math.max(0, drawn.lines.length - rows)));
+    // The picked entry stays in view (an entry taller than the pane shows its first lines).
+    if (input.focus === "detail" && view.entries.length > 0) {
+      if (drawn.from < start) start = drawn.from;
+      else if (drawn.to > start + rows) start = Math.min(drawn.from, drawn.to - rows);
+    }
+    input.layout.offset = start;
+    input.layout.total = drawn.lines.length;
+    input.layout.rows = rows;
+    body = drawn.lines.slice(start);
+  }
+  const detailPane = fill([...head, ...body], height);
+  if (!wide) return fill(input.focus === "detail" ? detailPane : listPane, height, width);
+  return fill(columns(listPane, detailPane, listWidth, detailWidth, " │ ", theme), height, width);
+}

package/src/lobby/tabs/plan.ts

@@ -45,6 +45,8 @@ export interface PlanView {
   nextMode?: RoundMode;
   seed?: PlannerSeed;
   saved?: PlannedTask;
+  /** How many tasks the plan was saved as, when it was split. */
+  savedParts?: number;
   title?: string;
   /** The round's questions wait for answers. */
   awaitingAnswers: boolean;
@@ -120,7 +122,7 @@ function statusLine(view: PlanView, input: PlanTabInput, theme?: LobbyTheme): st
   else if (view.reply?.status === "ready") parts.push(paint(theme, "success", `✓ ready — ${input.saveKey ?? "Ctrl+S"} saves it`));
   else if (view.awaitingAnswers) parts.push(paint(theme, "warning", `● ${count(view.questions.length, "question")} — enter ${view.answeredChunks > 0 ? "resumes" : "answers them"}`));
   if (view.lineComments.length > 0) parts.push(paint(theme, "accent", `◆ ${count(view.lineComments.length, "comment")} to send`));
-  if (view.saved) parts.push(paint(theme, "success", `saved as ${view.saved.id}`));
+  if (view.saved) parts.push(paint(theme, "success", view.savedParts && view.savedParts > 1 ? `saved as ${view.savedParts} tasks, from ${view.saved.id}` : `saved as ${view.saved.id}`));
   if (!view.busy && view.turns > 0) parts.push(paint(theme, "dim", roundLabel(view.turns, view.limit)));
   if (!view.busy && view.nextMode === "final") parts.push(paint(theme, "warning", "the next round is the last: the oracle settles the rest"));
   return parts.join(paint(theme, "dim", " · "));

package/src/lobby/tabs/tasks.ts

@@ -12,7 +12,7 @@ import { persistedRuns } from "../../pi/ui.ts";
 import { describeRun, runFromLog } from "../../pi/run-summary.ts";
 import { pendingApprovals } from "../../workflow/approvals.ts";
 import { textWidth } from "../../width.ts";
-import { ago, beside, bold, box, detailWindow, fill, markdownHanging, markdownLines, notePane, paint, position, rule, selectRow, since, spread, strike, windowStart, wrap, wrapHanging, type LobbyColor, type LobbyTheme, type PaneLayout } from "../layout.ts";
+import { ago, beside, BRANCH_GLYPH, bold, box, detailWindow, fill, markdownHanging, markdownLines, notePane, paint, position, rule, selectRow, since, spread, strike, windowStart, wrap, wrapHanging, type LobbyColor, type LobbyTheme, type PaneLayout } from "../layout.ts";
 
 export type TaskSection = "mine" | "others" | "pending" | "recent" | "archived";
 
@@ -114,7 +114,7 @@ export function taskRows(tasks: readonly Task[], plans: readonly PlannedTask[],
     ...plans.filter((plan) => plan.status === "pending").map((plan): TaskRow => ({
       kind: "plan",
       id: plan.id,
-      title: plan.title,
+      title: plan.split ? `${plan.title} (${plan.split.part}/${plan.split.of})` : plan.title,
       section: "pending",
       status: "pending",
       check: "open",
@@ -270,6 +270,10 @@ export function taskDetailLines(task: Task, comments: readonly PlanComment[], se
   lines.push(...wrapHanging("  ", facts.join(dot), width));
   const track = task.track ? (task.track.path === "fast" ? `fast track (${task.track.size})` : `full workflow (${task.track.size})`) : "";
   lines.push(...wrapHanging("  ", paint(theme, "dim", [task.id, track, task.domains.length > 0 ? task.domains.join(", ") : ""].filter(Boolean).join(" · ")), width));
+  if (task.git) {
+    const where = task.git.mode === "worktree" && task.git.path ? ` · worktree ${task.git.path}` : "";
+    lines.push(...wrapHanging("  ", paint(theme, "dim", `${BRANCH_GLYPH} ${task.git.branch}${task.git.from ? ` · from ${task.git.from}` : ""}${where}`), width));
+  }
   const steps = task.plan ? planChecklist(task.plan, persistedRuns(task)) : [];
   const done = steps.filter((step) => step.status === "done").length;
   if (steps.length > 0) {
@@ -331,6 +335,11 @@ export function planDetailLines(plan: PlannedTask, width: number, now: number, t
     ...wrapHanging("  ", paint(theme, "dim", plan.id), width),
   ];
   if (plan.issue) lines.push(...wrapHanging("  ", `from issue #${plan.issue.number} — ${plan.issue.title}${plan.issue.url ? ` ${paint(theme, "dim", plan.issue.url)}` : ""}`, width));
+  if (plan.split) {
+    const { part, of, titles, after } = plan.split;
+    lines.push(...wrapHanging("  ", `${paint(theme, "accent", `part ${part} of ${of}`)} of one plan that was split into tasks${after.length > 0 ? `, ${paint(theme, "warning", `after ${after.map((number) => `part ${number}`).join(" and ")}`)}` : ""}`, width));
+    lines.push(...wrapHanging("    ", titles.map((title, index) => (index + 1 === part ? bold(theme, `${index + 1}. ${title}`) : paint(theme, "muted", `${index + 1}. ${title}`))).join(paint(theme, "dim", " · ")), width));
+  }
   const key = (text: string) => paint(theme, "accent", text);
   lines.push("", ...wrapHanging("  ", [`${key("s")} ${paint(theme, "muted", "start it in a new session")}`, `${key("h")} ${paint(theme, "muted", "start it here")}`, `${key("d d")} ${paint(theme, "muted", "discard it")}`].join(paint(theme, "dim", "   ")), width));
   lines.push(...section("Agreed plan", width, theme), ...markdownLines(plan.brief, width, theme));