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

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));