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

package/src/execution/workspace.ts

@@ -0,0 +1,185 @@
+/**
+ * Where a task's work lives in git. A task can get a branch of its own
+ * (`branch`: created and checked out in the working folder) or a worktree of
+ * its own (`worktree`: a second checkout on that branch, which every agent of
+ * the task runs in, so tasks never trample each other's files). Both are named
+ * after the task. Every failure comes back as one readable line and the task
+ * simply runs without isolation: git being unusable must never stop a task.
+ */
+import { execFile } from "node:child_process";
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { promisify } from "node:util";
+import type { TaskGit } from "../schemas/task.ts";
+import { dataRoot } from "../state/project.ts";
+
+const run = promisify(execFile);
+const TIMEOUT_MS = 30_000;
+
+/** Runs git in a folder; resolves with trimmed stdout, rejects with git's own message. */
+export type GitRunner = (cwd: string, args: readonly string[]) => Promise<string>;
+
+export const runGit: GitRunner = async (cwd, args) => {
+  try {
+    const { stdout } = await run("git", [...args], { cwd, timeout: TIMEOUT_MS, maxBuffer: 10 * 1024 * 1024, windowsHide: true });
+    return stdout.trim();
+  } catch (error) {
+    const failure = error as { stderr?: string; message: string; code?: unknown };
+    // A missing git binary reads as that, not as a spawn error.
+    if (failure.code === "ENOENT") throw new Error("git is not installed");
+    throw new Error(firstLine(failure.stderr) || firstLine(failure.message) || "git failed");
+  }
+};
+
+function firstLine(text: string | undefined): string {
+  return text?.split("\n").find((line) => line.trim())?.trim().replace(/^(fatal|error):\s*/i, "") ?? "";
+}
+
+/** Where a task's worktrees live: `<project>/<configDir>/bot-lobby/worktrees`. */
+export function worktreesRoot(root: string, configDir: string): string {
+  return join(dataRoot(root, configDir), "worktrees");
+}
+
+/** A branch name git accepts, made from a task's friendly name (which already is one, bar odd characters). */
+export function branchName(name: string): string {
+  const cleaned = name
+    .trim()
+    .replace(/[\s~^:?*[\\]+/g, "-")
+    .replace(/@\{/g, "-")
+    .replace(/\.{2,}/g, ".")
+    .replace(/\/{2,}/g, "/")
+    .replace(/[\u0000-\u001f\u007f]/g, "")
+    .replace(/^[-./]+|[-./]+$/g, "")
+    .replace(/\.lock$/i, "");
+  return cleaned || "task";
+}
+
+/** The first of `name`, `name-2`, `name-3`… that no branch (local or remote) already uses. */
+async function freeBranch(git: GitRunner, top: string, name: string): Promise<string> {
+  const base = branchName(name);
+  for (let suffix = 1; suffix < 100; suffix += 1) {
+    const candidate = suffix === 1 ? base : `${base}-${suffix}`;
+    const taken = await git(top, ["for-each-ref", "--count=1", "--format=%(refname)", `refs/heads/${candidate}`, `refs/remotes/*/${candidate}`]).catch(() => "");
+    if (!taken) return candidate;
+  }
+  throw new Error(`every branch name like ${base} is taken`);
+}
+
+/** Keep the worktrees out of `git add -A` in the main checkout (a local exclude; nothing is committed). */
+async function excludeWorktrees(git: GitRunner, top: string, root: string, configDir: string): Promise<void> {
+  try {
+    const inside = relative(top, worktreesRoot(root, configDir));
+    if (!inside || inside.startsWith("..") || isAbsolute(inside)) return;
+    const file = resolve(top, await git(top, ["rev-parse", "--git-path", "info/exclude"]));
+    const line = `/${inside.split(sep).join("/")}/`;
+    const current = existsSync(file) ? readFileSync(file, "utf8") : "";
+    if (current.split("\n").some((entry) => entry.trim() === line)) return;
+    mkdirSync(dirname(file), { recursive: true });
+    appendFileSync(file, `${current && !current.endsWith("\n") ? "\n" : ""}# bot-lobby: one worktree per task\n${line}\n`);
+  } catch {
+    // Only a convenience: a read-only .git leaves the worktrees showing as untracked.
+  }
+}
+
+export interface WorkspaceRequest {
+  /** The folder the task starts from (the session's working folder). */
+  cwd: string;
+  root: string;
+  configDir: string;
+  /** The task's friendly name: the branch takes it. */
+  name: string;
+  mode: "branch" | "worktree";
+  git?: GitRunner;
+}
+
+/**
+ * Give a task its branch (or worktree and branch). Returns what was made, or
+ * one line saying why not (not a repository, no commits for a worktree, a
+ * failed checkout); the task then runs without.
+ */
+export async function createWorkspace(request: WorkspaceRequest): Promise<TaskGit | string> {
+  const git = request.git ?? runGit;
+  let top: string;
+  try {
+    top = await git(request.cwd, ["rev-parse", "--show-toplevel"]);
+  } catch {
+    return "this folder is not a git repository";
+  }
+  const [current, head] = await Promise.all([
+    git(top, ["branch", "--show-current"]).catch(() => ""),
+    git(top, ["rev-parse", "--verify", "HEAD"]).catch(() => ""),
+  ]);
+  let branch: string;
+  try {
+    branch = await freeBranch(git, top, request.name);
+    await git(top, ["check-ref-format", "--branch", branch]);
+  } catch (error) {
+    return `no valid branch name for ${request.name} — ${(error as Error).message}`;
+  }
+  const from = current || (head ? `detached at ${head.slice(0, 7)}` : undefined);
+  const base = { branch, ...(from ? { from } : {}), ...(head ? { base: head } : {}) };
+  if (request.mode === "branch") {
+    try {
+      await git(top, ["checkout", "-b", branch]);
+    } catch (error) {
+      return `could not create branch ${branch} — ${(error as Error).message}`;
+    }
+    return { mode: "branch", ...base };
+  }
+  if (!head) return "a worktree needs at least one commit to start from; commit first, or use a branch";
+  const path = join(worktreesRoot(request.root, request.configDir), branch);
+  try {
+    mkdirSync(dirname(path), { recursive: true });
+    await git(top, ["worktree", "add", "-b", branch, path, head]);
+  } catch (error) {
+    return `could not create a worktree for ${branch} — ${(error as Error).message}`;
+  }
+  await excludeWorktrees(git, top, request.root, request.configDir);
+  return { mode: "worktree", ...base, path };
+}
+
+/** The folder a task's agents run in: its worktree when it has one, otherwise where the session works. */
+export function taskCwd(task: { git?: TaskGit }, cwd: string): string {
+  return task.git?.mode === "worktree" && task.git.path ? task.git.path : cwd;
+}
+
+/** Why a task's worktree cannot be used (it was removed), or undefined when it is there or the task has none. */
+export function missingWorktree(task: { git?: TaskGit }): string | undefined {
+  const git = task.git;
+  if (git?.mode !== "worktree" || !git.path || existsSync(git.path)) return undefined;
+  return `the worktree ${git.path} of branch ${git.branch} is gone. Restore it with: git worktree add ${JSON.stringify(git.path)} ${git.branch}`;
+}
+
+/** The line that tells the oracle where the task's work lives; empty for a task without isolation. */
+export function gitLine(git: TaskGit | undefined): string {
+  if (!git) return "";
+  const from = git.from ? ` (from ${git.from})` : "";
+  if (git.mode === "branch") return `Git: this task works on its own branch ${git.branch}${from}, checked out in the working folder. Commit there; never switch branches.`;
+  return [
+    `Git: this task works in its own worktree ${git.path} on branch ${git.branch}${from}. Every agent runs there.`,
+    `Your own tools run in the main checkout, so look at the task's files under ${git.path} (git -C ${JSON.stringify(git.path)} diff --stat), and never edit outside it.`,
+    "Uncommitted changes in the main checkout are not in the worktree.",
+  ].join(" ");
+}
+
+/** What the lobby's title shows: the repository (or folder) and the branch checked out in it. */
+export interface WorkspaceInfo {
+  name: string;
+  branch?: string;
+}
+
+/** Repository (or folder) name and branch of a working folder; a folder outside git has only its name. */
+export async function describeWorkspace(cwd: string, git: GitRunner = runGit): Promise<WorkspaceInfo> {
+  let top: string;
+  try {
+    top = await git(cwd, ["rev-parse", "--show-toplevel"]);
+  } catch {
+    return { name: basename(cwd) || cwd };
+  }
+  const name = basename(top) || top;
+  const branch = await git(top, ["branch", "--show-current"]).catch(() => "");
+  if (branch) return { name, branch };
+  // Detached (or an unborn branch): the commit, when there is one.
+  const head = await git(top, ["rev-parse", "--short", "HEAD"]).catch(() => "");
+  return head ? { name, branch: `detached ${head}` } : { name };
+}

package/src/knowledge/edit.ts

@@ -0,0 +1,109 @@
+/**
+ * Knowledge files as entries the user can pick, edit, add and delete from the
+ * Knowledge tab. An entry is what reads as one item: a heading, a bullet with
+ * its wrapped and nested lines, or a paragraph. Everything here is pure text
+ * in, text out; the tab finds an entry again by its exact text (and which of
+ * several identical ones it is), so an edit made after the file changed on
+ * disk is refused rather than landing on the wrong line.
+ */
+
+export type EntryKind = "heading" | "bullet" | "text";
+
+export interface KnowledgeEntry {
+  /** The entry's lines exactly as the file has them. */
+  text: string;
+  /** First line, and the line after the last (indexes into the file's lines). */
+  start: number;
+  end: number;
+  kind: EntryKind;
+  /** Which of the entries with this same text it is (0 for the first). */
+  occurrence: number;
+}
+
+const HEADING = /^#{1,6}\s/;
+const BULLET = /^(?:[-*+]|\d+[.)])\s+\S/;
+
+/** The entries of a knowledge file, in order; blank lines separate them and belong to none. */
+export function parseEntries(content: string): KnowledgeEntry[] {
+  const lines = content.replace(/\r\n/g, "\n").split("\n");
+  const found: Array<{ start: number; end: number; kind: EntryKind }> = [];
+  let current: { start: number; end: number; kind: EntryKind } | undefined;
+  const close = () => {
+    if (current) found.push(current);
+    current = undefined;
+  };
+  lines.forEach((line, index) => {
+    if (!line.trim()) return close();
+    if (HEADING.test(line)) {
+      close();
+      found.push({ start: index, end: index + 1, kind: "heading" });
+      return;
+    }
+    if (BULLET.test(line)) {
+      close();
+      current = { start: index, end: index + 1, kind: "bullet" };
+      return;
+    }
+    // A wrapped or indented line joins the item above it; anything else starts a paragraph.
+    if (current) current.end = index + 1;
+    else current = { start: index, end: index + 1, kind: "text" };
+  });
+  close();
+  const seen = new Map<string, number>();
+  return found.map(({ start, end, kind }) => {
+    const text = lines.slice(start, end).join("\n");
+    const occurrence = seen.get(text) ?? 0;
+    seen.set(text, occurrence + 1);
+    return { text, start, end, kind, occurrence };
+  });
+}
+
+/** The entry with this exact text (the `occurrence`-th one), or undefined when the file no longer has it. */
+export function findEntry(content: string, text: string, occurrence = 0): KnowledgeEntry | undefined {
+  return parseEntries(content).find((entry) => entry.text === text && entry.occurrence === occurrence);
+}
+
+function linesOf(content: string): string[] {
+  const text = content.replace(/\r\n/g, "\n").replace(/\n+$/, "");
+  return text ? text.split("\n") : [];
+}
+
+/** `text` as a bullet: its first line after `- `, the rest indented under it; text that already is a bullet or heading stays as written. */
+export function bulletOf(text: string): string {
+  const trimmed = text.replace(/^\s*\n+|\s+$/g, "");
+  if (!trimmed.trim()) return "";
+  if (BULLET.test(trimmed) || HEADING.test(trimmed)) return trimmed;
+  const [first = "", ...rest] = trimmed.split("\n");
+  return [`- ${first}`, ...rest.map((line) => (line.trim() ? `  ${line.trimStart()}` : ""))].join("\n");
+}
+
+/** The file with `entry` replaced by `text`, exactly as written (a blank text removes it). */
+export function replaceEntry(content: string, entry: KnowledgeEntry, text: string): string {
+  const body = text.replace(/\s+$/, "");
+  if (!body.trim()) return removeEntry(content, entry);
+  const lines = linesOf(content);
+  lines.splice(entry.start, entry.end - entry.start, ...body.split("\n"));
+  return `${lines.join("\n")}\n`;
+}
+
+/** The file without `entry`; the blank line it leaves doubled up is dropped with it. */
+export function removeEntry(content: string, entry: KnowledgeEntry): string {
+  const lines = linesOf(content);
+  lines.splice(entry.start, entry.end - entry.start);
+  const before = lines[entry.start - 1];
+  const after = lines[entry.start];
+  if (entry.start < lines.length && after !== undefined && !after.trim() && (before === undefined || !before.trim())) lines.splice(entry.start, 1);
+  else if (entry.start >= lines.length && lines.length > 0 && !lines[lines.length - 1]!.trim()) lines.pop();
+  return lines.length > 0 ? `${lines.join("\n")}\n` : "";
+}
+
+/** The file with a new bullet after `entry` (at the end without one); after a paragraph it gets a blank line first. */
+export function insertAfter(content: string, entry: KnowledgeEntry | undefined, text: string): string {
+  const added = bulletOf(text);
+  if (!added.trim()) return content;
+  const lines = linesOf(content);
+  const at = entry ? entry.end : lines.length;
+  const addition = entry?.kind === "text" || (!entry && lines.length > 0 && lines[lines.length - 1]!.trim() && !BULLET.test(lines[lines.length - 1]!)) ? ["", ...added.split("\n")] : added.split("\n");
+  lines.splice(at, 0, ...addition);
+  return `${lines.join("\n")}\n`;
+}

package/src/knowledge/notes.ts

@@ -0,0 +1,143 @@
+/**
+ * The user's comments on knowledge: notes about one entry of an agent's
+ * knowledge file ("outdated, we moved to Redis"). They live in one
+ * append-only JSON-lines log per project, never inside the knowledge files
+ * (agents rewrite those when they compact them), and reach every agent that
+ * reads the knowledge: `annotate` puts each note right under its entry, so it
+ * travels with the entry into the prompt and the agent weighs it there.
+ *
+ * A note is tied to its entry by the entry's exact text. Editing the entry
+ * from the Knowledge tab moves its notes to the new text; a note whose entry
+ * changed some other way is kept, and shown under the file as detached.
+ */
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { randomUUID } from "node:crypto";
+import type { KnowledgeAgent } from "./paths.ts";
+import { parseEntries } from "./edit.ts";
+
+export interface KnowledgeNote {
+  id: string;
+  agent: KnowledgeAgent;
+  /** The knowledge file, e.g. `decisions.md`. */
+  file: string;
+  /** The exact text of the entry it is about. */
+  entry: string;
+  text: string;
+  createdAt: string;
+  /** The pi session that wrote it, when known. */
+  by?: string;
+}
+
+type NoteEvent =
+  | { kind: "note"; id: string; agent: KnowledgeAgent; file: string; entry: string; text: string; at: string; by?: string }
+  | { kind: "move"; id: string; entry: string; at: string }
+  | { kind: "remove"; id: string; at: string };
+
+/** Longest note kept; agents read it verbatim. */
+export const MAX_NOTE_CHARS = 2000;
+
+export function notesPath(dataRoot: string): string {
+  return join(dataRoot, "knowledge-comments.jsonl");
+}
+
+function append(dataRoot: string, event: NoteEvent): void {
+  const path = notesPath(dataRoot);
+  mkdirSync(dirname(path), { recursive: true });
+  appendFileSync(path, `${JSON.stringify(event)}\n`, "utf8");
+}
+
+/** The notes as they stand, oldest first. A torn line from a crashed writer is skipped. */
+export function readNotes(dataRoot: string | undefined): KnowledgeNote[] {
+  if (!dataRoot) return [];
+  const path = notesPath(dataRoot);
+  if (!existsSync(path)) return [];
+  let text: string;
+  try {
+    text = readFileSync(path, "utf8");
+  } catch {
+    return [];
+  }
+  const notes = new Map<string, KnowledgeNote>();
+  for (const line of text.split("\n")) {
+    if (!line.trim()) continue;
+    let event: NoteEvent;
+    try {
+      event = JSON.parse(line) as NoteEvent;
+    } catch {
+      continue;
+    }
+    if (!event || typeof event.id !== "string") continue;
+    if (event.kind === "note" && !notes.has(event.id) && typeof event.text === "string" && typeof event.entry === "string") {
+      notes.set(event.id, { id: event.id, agent: event.agent, file: event.file, entry: event.entry, text: event.text, createdAt: event.at, ...(event.by ? { by: event.by } : {}) });
+    } else if (event.kind === "move" && typeof event.entry === "string") {
+      const note = notes.get(event.id);
+      if (note) note.entry = event.entry;
+    } else if (event.kind === "remove") notes.delete(event.id);
+  }
+  return [...notes.values()];
+}
+
+/** Leave a note on an entry. */
+export function addNote(dataRoot: string, note: { agent: KnowledgeAgent; file: string; entry: string; text: string; by?: string }, now = new Date()): KnowledgeNote {
+  const text = note.text.trim().slice(0, MAX_NOTE_CHARS);
+  if (!text) throw new Error("a note needs some words");
+  if (!note.entry.trim()) throw new Error("a note needs an entry to be about");
+  const id = randomUUID().slice(0, 8);
+  const at = now.toISOString();
+  append(dataRoot, { kind: "note", id, agent: note.agent, file: note.file, entry: note.entry, text, at, ...(note.by ? { by: note.by } : {}) });
+  return { id, agent: note.agent, file: note.file, entry: note.entry, text, createdAt: at, ...(note.by ? { by: note.by } : {}) };
+}
+
+export function removeNote(dataRoot: string, id: string, now = new Date()): void {
+  append(dataRoot, { kind: "remove", id, at: now.toISOString() });
+}
+
+/** Move every note on `from` to `to`: the entry was edited, its notes stay with it. Returns how many moved. */
+export function moveNotes(dataRoot: string, agent: KnowledgeAgent, file: string, from: string, to: string, now = new Date()): number {
+  if (from === to) return 0;
+  const moving = readNotes(dataRoot).filter((note) => note.agent === agent && note.file === file && note.entry === from);
+  for (const note of moving) append(dataRoot, { kind: "move", id: note.id, entry: to, at: now.toISOString() });
+  return moving.length;
+}
+
+/** Drop every note on `entry`: the entry was deleted. Returns how many went. */
+export function removeNotesOn(dataRoot: string, agent: KnowledgeAgent, file: string, entry: string, now = new Date()): number {
+  const going = readNotes(dataRoot).filter((note) => note.agent === agent && note.file === file && note.entry === entry);
+  for (const note of going) removeNote(dataRoot, note.id, now);
+  return going.length;
+}
+
+/** `> Note from the user: …` with every line of a longer note quoted. */
+function noteLines(note: KnowledgeNote, about?: string): string[] {
+  const [first = "", ...rest] = note.text.split("\n");
+  const lead = about ? `Note from the user about "${about}": ` : "Note from the user: ";
+  return [`> ${lead}${first}`, ...rest.map((line) => `> ${line}`)];
+}
+
+/**
+ * A file's text with each note under the entry it is about, as the agents
+ * read it. A note whose entry is gone is added at the end, naming the entry it
+ * was about, so what the user said is never lost. Notes the text already
+ * carries (an agent copied them in when it compacted the file) are not added twice.
+ */
+export function annotate(content: string, notes: readonly KnowledgeNote[]): string {
+  if (notes.length === 0) return content;
+  const lines = content.replace(/\r\n/g, "\n").split("\n");
+  const entries = parseEntries(content);
+  const carried = (note: KnowledgeNote) => content.includes(noteLines(note)[0]!);
+  const pending = notes.filter((note) => !carried(note));
+  const detached: KnowledgeNote[] = [];
+  const under = new Map<number, KnowledgeNote[]>();
+  for (const note of pending) {
+    const entry = entries.find((candidate) => candidate.text === note.entry);
+    if (!entry) detached.push(note);
+    else under.set(entry.end, [...(under.get(entry.end) ?? []), note]);
+  }
+  // Bottom-up, so earlier positions stay where they are.
+  for (const at of [...under.keys()].sort((a, b) => b - a)) lines.splice(at, 0, ...under.get(at)!.flatMap((note) => noteLines(note)));
+  const body = lines.join("\n").replace(/\n+$/, "");
+  if (detached.length === 0) return body;
+  const about = (note: KnowledgeNote) => note.entry.replace(/\s+/g, " ").trim().slice(0, 60);
+  return `${body}\n\n${detached.flatMap((note) => noteLines(note, about(note))).join("\n")}`;
+}

package/src/knowledge/selector.ts

@@ -36,7 +36,7 @@ export function splitSections(markdown: string): string[] {
     .filter((part) => part.length > 0);
 }
 
-function score(sectionText: string, tokens: string[]): number {
+export function score(sectionText: string, tokens: string[]): number {
   const lower = sectionText.toLowerCase();
   return tokens.reduce((total, token) => total + (lower.includes(token) ? 1 : 0), 0);
 }

package/src/knowledge/store.ts

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { knowledgeDir, STANDARDS_FILE, type KnowledgeAgent } from "./paths.ts";
+import { annotate, readNotes } from "./notes.ts";
 
 export function readFileOr(path: string, fallback = ""): string {
   try {
@@ -105,7 +106,20 @@ export function readKnowledgeSlices(
   };
 }
 
-/** Read an agent's knowledge by agent key; bot-lobby dirs win per file over the pre-rename ones. */
+/**
+ * Read an agent's knowledge by agent key; bot-lobby dirs win per file over the
+ * pre-rename ones. The user's notes on entries (Knowledge tab) sit right under
+ * the entries they are about, so every agent reads them with the knowledge.
+ */
 export function readAgentKnowledge(roots: readonly string[], agent: KnowledgeAgent) {
-  return readKnowledgeSlices(roots.map((root) => knowledgeDir(root, agent)), STANDARDS_FILE[agent]);
+  const slices = readKnowledgeSlices(roots.map((root) => knowledgeDir(root, agent)), STANDARDS_FILE[agent]);
+  const notes = readNotes(roots[0]).filter((note) => note.agent === agent);
+  if (notes.length === 0) return slices;
+  const about = (file: string) => notes.filter((note) => note.file === file);
+  return {
+    knowledge: annotate(slices.knowledge, about("knowledge.md")),
+    standards: annotate(slices.standards, about(STANDARDS_FILE[agent])),
+    decisions: annotate(slices.decisions, about("decisions.md")),
+    completed: annotate(slices.completed, about("completed-tasks.md")),
+  };
 }

package/src/lobby/ask.ts

@@ -6,7 +6,7 @@
  * answers become the user's turn for the next round.
  */
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { PanelQuestion } from "./planner.ts";
+import type { PanelQuestion, SettledQuestion } from "./planner.ts";
 import { MAX_HEADER, MAX_LABEL, MAX_OPTIONS, MAX_QUESTIONS, MIN_OPTIONS, RESERVED, type AskAnswer, type AskOption, type AskQuestion, type AskResult } from "../ask/types.ts";
 import type { Asker } from "../ask/dialog.ts";
 
@@ -64,6 +64,35 @@ function answerText(answer: AskAnswer | undefined): string | undefined {
   return answer.answer?.trim() || undefined;
 }
 
+/** A multi-line answer keeps its lines under the `→` that opens it. */
+function indented(text: string, by: string): string {
+  return text.replace(/\n/g, `\n${by}`);
+}
+
+/** Every question of the round with the answer the user gave it, in the order asked. */
+function answered(questions: readonly PanelQuestion[], results: readonly AskResult[]): Array<{ number: number; question: PanelQuestion; answer: AskAnswer | undefined; text: string | undefined }> {
+  const rows: Array<{ number: number; question: PanelQuestion; answer: AskAnswer | undefined; text: string | undefined }> = [];
+  results.forEach((result, chunk) => {
+    const offset = chunk * MAX_QUESTIONS;
+    for (let i = 0; i < MAX_QUESTIONS; i++) {
+      const question = questions[offset + i];
+      if (!question) break;
+      const answer = result.answers.find((entry) => entry.questionIndex === i);
+      rows.push({ number: offset + i + 1, question, answer, text: answerText(answer) });
+    }
+  });
+  return rows;
+}
+
+/**
+ * What the user's reply settled: each question of the round with its answer,
+ * or without one when they left it. The panel is never allowed to ask a
+ * settled question again.
+ */
+export function settledQuestions(questions: readonly PanelQuestion[], results: readonly AskResult[]): SettledQuestion[] {
+  return answered(questions, results).map(({ question, text }) => ({ from: question.from, question: question.text.replace(/\s+/g, " ").trim(), ...(text ? { answer: text } : {}) }));
+}
+
 /**
  * The user's turn for the next round: every question with who asked it and
  * the answer (`→ …`), their notes, and what they left unanswered. Undefined
@@ -72,27 +101,19 @@ function answerText(answer: AskAnswer | undefined): string | undefined {
 export function answerMessage(questions: readonly PanelQuestion[], results: readonly AskResult[]): string | undefined {
   const lines: string[] = [];
   const skipped: string[] = [];
-  const notes: string[] = [];
-  let answered = 0;
-  results.forEach((result, chunk) => {
-    if (result.globalNote?.trim()) notes.push(result.globalNote.trim());
-    const offset = chunk * MAX_QUESTIONS;
-    for (let i = 0; i < MAX_QUESTIONS; i++) {
-      const question = questions[offset + i];
-      if (!question) break;
-      const answer = result.answers.find((entry) => entry.questionIndex === i);
-      const text = answerText(answer);
-      const label = `${offset + i + 1}. [${question.from}] ${question.text.replace(/\s+/g, " ").trim()}`;
-      if (!text) {
-        skipped.push(label);
-        continue;
-      }
-      answered += 1;
-      lines.push(`${label}\n   → ${text}${answer?.kind === "custom" ? " (in my words)" : ""}`);
-      if (answer?.notes?.trim()) lines.push(`   note: ${answer.notes.trim()}`);
+  const notes = results.map((result) => result.globalNote?.trim()).filter((note): note is string => Boolean(note));
+  let count = 0;
+  for (const { number, question, answer, text } of answered(questions, results)) {
+    const label = `${number}. [${question.from}] ${question.text.replace(/\s+/g, " ").trim()}`;
+    if (!text) {
+      skipped.push(label);
+      continue;
     }
-  });
-  if (answered === 0 && notes.length === 0) return undefined;
+    count += 1;
+    lines.push(`${label}\n   → ${indented(text, "     ")}${answer?.kind === "custom" ? " (in my words)" : ""}`);
+    if (answer?.notes?.trim()) lines.push(`   note: ${indented(answer.notes.trim(), "     ")}`);
+  }
+  if (count === 0 && notes.length === 0) return undefined;
   return [
     "Answers to the panel's questions:",
     ...lines,

package/src/lobby/feed.ts

@@ -70,6 +70,8 @@ export class LobbyFeed {
   private readonly runSteps = new Map<string, string>();
   private readonly runThoughts = new Map<string, string>();
   private readonly runStatus = new Map<string, AgentRun["status"]>();
+  /** Runs already reported as switched to their fallback model. */
+  private readonly fellBack = new Set<string>();
 
   onChange(listener: () => void): () => void {
     this.listeners.add(listener);
@@ -200,6 +202,10 @@ export class LobbyFeed {
       const before = this.runStatus.get(key);
       this.runStatus.set(key, run.status);
       if (before === undefined) this.log(source, `started as ${run.role}`, "info", at);
+      if (run.fellBackFrom && !this.fellBack.has(key)) {
+        this.fellBack.add(key);
+        this.log(source, `${run.fellBackFrom} is out of usage or unavailable: running on the fallback model`, "warning", at);
+      }
       if (run.step && this.runSteps.get(key) !== run.step) {
         this.runSteps.set(key, run.step);
         this.step(source, run.step, key, at);
@@ -225,6 +231,7 @@ export class LobbyFeed {
     this.runSteps.clear();
     this.runThoughts.clear();
     this.runStatus.clear();
+    this.fellBack.clear();
     this.touch();
   }
 }

package/src/lobby/issues.ts

@@ -63,7 +63,7 @@ export function ghError(result: Partial<ExecResult> & { error?: string }): strin
   return first.length > 160 ? `${first.slice(0, 159)}…` : first;
 }
 
-async function gh(exec: Exec, cwd: string, args: string[]): Promise<string> {
+export async function gh(exec: Exec, cwd: string, args: string[]): Promise<string> {
   let result: ExecResult;
   try {
     result = await exec("gh", args, { cwd, timeout: TIMEOUT_MS });