@a-t-h-i/bot-lobby 0.5.0 → 0.5.1

package/src/lobby/layout.ts

@@ -26,7 +26,9 @@ export interface LobbyTheme {
   fg(color: LobbyColor, text: string): string;
   bold(text: string): string;
   italic?(text: string): string;
-  bg?(color: "selectedBg", text: string): string;
+  bg?(color: "selectedBg" | "searchMatchBg", text: string): string;
+  /** Render Markdown to styled lines; plain wrapping without it (tests). */
+  markdown?(text: string, width: number): string[];
 }
 
 /** Paint only when a theme is present; tests without one get plain text. */
@@ -45,7 +47,7 @@ export function italic(theme: LobbyTheme | undefined, text: string): string {
 /** Exactly `width` columns: truncated with an ellipsis, or padded with spaces. */
 export function fit(text: string, width: number): string {
   if (width <= 0) return "";
-  const cut = visibleWidth(text) > width ? truncateToWidth(text, width) : text;
+  const cut = visibleWidth(text) > width ? truncateToWidth(text, width, "…") : text;
   const pad = width - visibleWidth(cut);
   return pad > 0 ? `${cut}${" ".repeat(pad)}` : cut;
 }
@@ -165,10 +167,197 @@ export function spinner(tick: number): string {
   return SPINNER[((tick % SPINNER.length) + SPINNER.length) % SPINNER.length]!;
 }
 
-/** Light Markdown for plans and reports: headings bold without their `#`, everything else wrapped as written. */
+/** Markdown for plans, reports and replies: the theme's renderer, or headings bold without their `#` and the rest wrapped. */
 export function markdownLines(text: string, width: number, theme?: LobbyTheme): string[] {
+  if (theme?.markdown) return theme.markdown(text, width);
   return text.split("\n").flatMap((line) => {
     const heading = /^#{1,6}\s+(.*)$/.exec(line);
     return wrap(heading ? bold(theme, paint(theme, "mdHeading", heading[1]!)) : line, width);
   });
 }
+
+/** Markdown behind a hanging lead (`oracle ▸ `): the first line carries the lead, the rest align under it. */
+export function markdownHanging(lead: string, text: string, width: number, theme?: LobbyTheme): string[] {
+  const indent = visibleWidth(lead);
+  const body = markdownLines(text, Math.max(1, width - indent), theme);
+  if (body.length === 0) return [lead];
+  return body.map((line, index) => (index === 0 ? `${lead}${line}` : line ? `${" ".repeat(indent)}${line}` : ""));
+}
+
+export interface BoxOptions {
+  title?: string;
+  /** Muted text at the right end of the top border. */
+  right?: string;
+  /** The box that has the keyboard: its border takes the accent colour. */
+  focused?: boolean;
+  theme?: LobbyTheme;
+  /** Content longer than the box: `total` lines, the first shown at `start`; drawn as a thumb on the right border. */
+  scroll?: { total: number; start: number };
+}
+
+/** A scrollable pane as a render laid it out: its box in body cells, and its content against its rows. */
+export interface PaneBox {
+  top: number;
+  left: number;
+  width: number;
+  height: number;
+  /** Lines of content, and rows showing them at once. */
+  total: number;
+  rows: number;
+}
+
+/** Scrollable panes by name, filled in by a tab's render so the lobby can clamp offsets and route the wheel. */
+export type PaneLayout = Map<string, PaneBox>;
+
+/** Record a pane that sits at `top`/`left` in the body, `width` × `height`, showing `total` lines. */
+export function notePane(panes: PaneLayout | undefined, name: string, top: number, left: number, width: number, height: number, total: number): void {
+  panes?.set(name, { top, left, width, height, total, rows: Math.max(0, height - 2) });
+}
+
+/** First line of a top-anchored pane scrolled `offset` lines down, stopping when its last line shows. */
+export function detailWindow(total: number, rows: number, offset: number): number {
+  return Math.max(0, Math.min(offset, total - Math.max(1, rows)));
+}
+
+/** `12–40/96`: the lines a pane shows out of all it holds. */
+export function position(start: number, rows: number, total: number): string {
+  return `${start + 1}–${Math.min(total, start + rows)}/${total}`;
+}
+
+/** The rows of a `rows`-tall track that the thumb covers, or undefined when everything fits. */
+export function scrollThumb(total: number, rows: number, start: number): { from: number; to: number } | undefined {
+  if (rows <= 0 || total <= rows) return undefined;
+  const size = Math.max(1, Math.round((rows * rows) / total));
+  const max = total - rows;
+  const from = Math.round((Math.min(max, Math.max(0, start)) / max) * (rows - size));
+  return { from, to: from + size };
+}
+
+/**
+ * A rounded panel exactly `width` × `height`: the title set into the top
+ * border, `content` inside with one column of padding, extra lines cut and
+ * missing ones blank. Below 4 columns or 2 rows it degrades to plain lines.
+ */
+export function box(width: number, height: number, content: readonly string[], options: BoxOptions = {}): string[] {
+  if (height <= 0) return [];
+  if (width < 4 || height < 2) return fill(content, height, Math.max(0, width));
+  const { theme, focused } = options;
+  const edge = (text: string) => paint(theme, focused ? "borderAccent" : "borderMuted", text);
+  const inner = width - 4;
+  const title = options.title ? ` ${options.title} ` : "";
+  const right = options.right ? ` ${options.right} ` : "";
+  let room = width - 2 - visibleWidth(title) - visibleWidth(right);
+  const shownRight = room >= 1 ? right : "";
+  room = width - 2 - visibleWidth(title) - visibleWidth(shownRight);
+  const titled = room >= 1 ? title : fit(title, Math.max(0, width - 3));
+  const fillWidth = Math.max(0, width - 2 - visibleWidth(titled) - visibleWidth(shownRight));
+  const paintedTitle = titled ? bold(theme, paint(theme, focused ? "accent" : "text", titled)) : "";
+  const top = `${edge("╭")}${paintedTitle}${edge("─".repeat(fillWidth))}${shownRight ? paint(theme, "dim", shownRight) : ""}${edge("╮")}`;
+  const thumb = options.scroll ? scrollThumb(options.scroll.total, height - 2, options.scroll.start) : undefined;
+  const rightEdge = (row: number) => (thumb && row >= thumb.from && row < thumb.to ? paint(theme, focused ? "accent" : "muted", "┃") : edge("│"));
+  const rows = fill(content, height - 2).map((line, row) => `${edge("│")} ${fit(line, inner)} ${rightEdge(row)}`);
+  return [top, ...rows, `${edge("╰")}${edge("─".repeat(width - 2))}${edge("╯")}`];
+}
+
+/** Lay boxes out side by side, each already exactly its width and the same height. */
+export function beside(panes: ReadonlyArray<readonly string[]>, gap = " "): string[] {
+  const height = Math.max(0, ...panes.map((pane) => pane.length));
+  return Array.from({ length: height }, (_, row) => panes.map((pane) => pane[row] ?? "").join(gap));
+}
+
+/** Escape sequences (CSI, OSC, APC) that take no columns. */
+const ESCAPE = /\x1b(?:\[[0-9;?]*[ -\/]*[@-~]|\][^\x07\x1b]*(?:\x07|\x1b\\)|_[^\x07\x1b]*(?:\x07|\x1b\\))/y;
+
+/**
+ * Mark every case-insensitive occurrence of `query` in a styled line with
+ * reverse video. Escape sequences are skipped when matching and kept intact,
+ * and reverse video is switched off (not reset) so the line's own colours
+ * carry on after each match.
+ */
+export function highlight(line: string, query: string): string {
+  const needle = query.trim().toLowerCase();
+  if (!needle) return line;
+  // Visible characters with their raw offsets.
+  const chars: Array<{ ch: string; at: number }> = [];
+  for (let i = 0; i < line.length; ) {
+    ESCAPE.lastIndex = i;
+    const escape = ESCAPE.exec(line);
+    if (escape) {
+      i += escape[0].length;
+      continue;
+    }
+    const point = line.codePointAt(i)!;
+    const ch = String.fromCodePoint(point);
+    chars.push({ ch, at: i });
+    i += ch.length;
+  }
+  const visible = chars.map((entry) => entry.ch).join("").toLowerCase();
+  const starts: Array<[number, number]> = [];
+  for (let from = visible.indexOf(needle); from >= 0; from = visible.indexOf(needle, from + needle.length)) starts.push([from, from + needle.length]);
+  if (starts.length === 0) return line;
+  // Map visible string offsets back to char indexes (they differ only for astral characters).
+  const charAt: number[] = [];
+  chars.forEach((entry, index) => {
+    for (let k = 0; k < entry.ch.length; k++) charAt.push(index);
+  });
+  let out = "";
+  let cursor = 0;
+  for (const [start, end] of starts) {
+    const from = chars[charAt[start]!]!.at;
+    const lastChar = chars[charAt[end - 1]!]!;
+    const to = lastChar.at + lastChar.ch.length;
+    out += `${line.slice(cursor, from)}\x1b[7m${line.slice(from, to)}\x1b[27m`;
+    cursor = to;
+  }
+  return out + line.slice(cursor);
+}
+
+const EIGHTHS = ["", "▏", "▎", "▍", "▌", "▋", "▊", "▉"];
+
+/** A horizontal bar `value / max` of `width` cells, with eighth-cell precision at its end. */
+export function bar(value: number, max: number, width: number): string {
+  if (width <= 0 || !Number.isFinite(value) || !Number.isFinite(max) || max <= 0 || value <= 0) return "";
+  const cells = Math.min(width, (value / max) * width);
+  const whole = Math.floor(cells);
+  const part = EIGHTHS[Math.round((cells - whole) * 8)] ?? "";
+  // A non-zero value always shows at least a sliver.
+  return `${"█".repeat(whole)}${part}` || "▏";
+}
+
+/** A meter `fraction` full: filled cells over a dim track, exactly `width` wide. */
+export function meter(fraction: number, width: number, fillPaint: (text: string) => string, trackPaint: (text: string) => string): string {
+  if (width <= 0) return "";
+  const safe = Number.isFinite(fraction) ? Math.min(1, Math.max(0, fraction)) : 0;
+  const filled = Math.round(safe * width);
+  return `${fillPaint("━".repeat(filled))}${trackPaint("─".repeat(width - filled))}`;
+}
+
+const SPARKS = ["▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"];
+
+/** A sparkline of the last `width` values, scaled between their min and max. */
+export function sparkline(values: readonly number[], width: number): string {
+  const shown = values.filter((value) => Number.isFinite(value)).slice(-Math.max(0, width));
+  if (shown.length === 0) return "";
+  const low = Math.min(...shown);
+  const high = Math.max(...shown);
+  const span = high - low;
+  return shown.map((value) => SPARKS[span === 0 ? 3 : Math.min(7, Math.floor(((value - low) / span) * 8))]).join("");
+}
+
+/**
+ * A part-to-whole bar: each segment's share of `width` cells in its own
+ * colour, rounded so the segments always fill the bar exactly.
+ */
+export function stackedBar(segments: ReadonlyArray<{ value: number; paint: (text: string) => string }>, width: number): string {
+  const total = segments.reduce((sum, segment) => sum + Math.max(0, segment.value), 0);
+  if (width <= 0 || total <= 0) return "";
+  let used = 0;
+  let acc = 0;
+  return segments.map((segment) => {
+    acc += Math.max(0, segment.value);
+    const end = Math.round((acc / total) * width);
+    const cells = end - used;
+    used = end;
+    return cells > 0 ? segment.paint("█".repeat(cells)) : "";
+  }).join("");
+}

package/src/lobby/markdown.ts

@@ -0,0 +1,48 @@
+/**
+ * Markdown for the lobby: pi's own renderer (headings, emphasis, lists, code
+ * with syntax highlighting, quotes, tables) under the session's theme, with
+ * heading hashes dropped for a cleaner read. Renders are cached per theme,
+ * width and text, since the lobby repaints several times a second.
+ */
+import { getMarkdownTheme } from "@earendil-works/pi-coding-agent";
+import { Markdown, stripTerminalSequences, type MarkdownTheme } from "@earendil-works/pi-tui";
+
+export type MarkdownRenderer = (text: string, width: number) => string[];
+
+const CACHE_LIMIT = 96;
+
+/** A heading line as pi renders it: optional styling, then `#`…`######` and a space. */
+const HEADING_HASHES = /^((?:\x1b\[[0-9;]*m)*)#{1,6} ((?:\x1b\[[0-9;]*m)*)/;
+
+/** Drop the `### ` pi keeps in front of headings, and make them bold. */
+export function tidyHeading(line: string, bold: (text: string) => string): string {
+  if (!/^#{1,6} /.test(stripTerminalSequences(line))) return line;
+  const body = line.replace(HEADING_HASHES, "$1$2");
+  return bold(body.trimEnd());
+}
+
+/**
+ * A renderer bound to a theme provider. `theme()` is read on every call, so a
+ * theme switch re-renders instead of serving stale colours from the cache.
+ */
+export function createMarkdownRenderer(theme: () => MarkdownTheme = getMarkdownTheme): MarkdownRenderer {
+  const caches = new WeakMap<object, Map<string, string[]>>();
+  return (text, width) => {
+    const current = theme();
+    let cache = caches.get(current);
+    if (!cache) {
+      cache = new Map();
+      caches.set(current, cache);
+    }
+    const key = `${width}\0${text}`;
+    const hit = cache.get(key);
+    if (hit) return hit;
+    const lines = new Markdown(text, 0, 0, current).render(Math.max(1, width)).map((line) => tidyHeading(line.trimEnd(), current.bold));
+    // Drop the blank lines pi pads the render with at either end.
+    while (lines.length > 0 && !lines[0]!.trim()) lines.shift();
+    while (lines.length > 0 && !lines.at(-1)!.trim()) lines.pop();
+    cache.set(key, lines);
+    if (cache.size > CACHE_LIMIT) cache.delete(cache.keys().next().value!);
+    return lines;
+  };
+}

package/src/lobby/planner.ts

@@ -22,6 +22,7 @@ import { PANEL_MEMBERS, type PanelMember } from "../schemas/configuration.ts";
 import { truncate } from "../text.ts";
 import type { LobbyFeed } from "./feed.ts";
 import type { QuickFixProfile } from "./quickfix.ts";
+import type { AskResult } from "./ask.ts";
 
 /** Seats and the oracle read the repository to ask informed questions; they never edit. */
 export const PLANNER_TOOLS: readonly string[] = ["read", "grep", "find", "ls"];
@@ -41,10 +42,21 @@ const MEMBER_SEATS: Record<PanelMember, string> = {
   researcher: "You are RESEARCH: facts outside the repository — libraries and versions, standards, APIs and documentation, known pitfalls and prior art. Use the web tools when you have them and cite a URL for every external claim; ask the user to choose where the options you found really differ.",
 };
 
-export interface PanelQuestion {
+/** One answer the asker offers: a short label and what choosing it means. */
+export interface PanelOption {
+  label: string;
+  description: string;
+}
+
+/** A question as a seat or the oracle wrote it, with the options it offers (recommended first). */
+export interface AskedQuestion {
+  text: string;
+  options: PanelOption[];
+}
+
+export interface PanelQuestion extends AskedQuestion {
   /** DEV, DESIGN, QA, RESEARCH or ORACLE. */
   from: string;
-  text: string;
 }
 
 export interface PlannerMessage {
@@ -59,14 +71,14 @@ export interface PlannerMessage {
 export interface PlannerReply {
   status: "grilling" | "ready";
   title?: string;
-  questions: string[];
+  questions: AskedQuestion[];
   plan?: string;
 }
 
 /** A seat's reply: whether its domain is settled, its questions and what the plan must respect. */
 export interface MemberReply {
   status: "open" | "ready";
-  questions: string[];
+  questions: AskedQuestion[];
   notes: string[];
 }
 
@@ -104,6 +116,8 @@ export interface PlannerDeps {
   feed?: LobbyFeed;
   runProcess?: ProcessRunner;
   onChange?: () => void;
+  /** Called when a round ends (answered, failed or stopped), so the lobby can put the questions to the user. */
+  onRound?: (session: PlanningSession) => void;
 }
 
 /** Split a reply into its top-level `## Section` bodies, keyed by lower-case title. */
@@ -137,6 +151,53 @@ function listItems(body: string | undefined): string[] {
   return items;
 }
 
+/** `Label — what it means` (or `Label: …`, `Label - …`); bold markers dropped. */
+export function parseOption(text: string): PanelOption {
+  const flat = text.replace(/\*\*/g, "").trim();
+  const split = /^(.*?)\s+(?:—|–|-)\s+(.+)$/.exec(flat) ?? /^([^:]{1,60}):\s+(.+)$/.exec(flat);
+  return split ? { label: split[1]!.trim(), description: split[2]!.trim() } : { label: flat, description: "" };
+}
+
+/** Inline `a) … b) …` choices, when a question carries its options in its own text. */
+function inlineOptions(question: AskedQuestion): AskedQuestion {
+  if (question.options.length > 0) return question;
+  const parts = question.text.split(/\s(?=[a-d]\)\s)/);
+  if (parts.length < 3) return question;
+  const options = parts.slice(1).map((part) => parseOption(part.replace(/^[a-d]\)\s+/, "").replace(/[;,.]\s*$/, "")));
+  return { text: parts[0]!.trim(), options };
+}
+
+/**
+ * Numbered or bulleted questions, each with the options indented beneath it
+ * (`   - Users table (Recommended) — follows the user`); continuation lines
+ * join the question or the option they follow.
+ */
+export function questionItems(body: string | undefined): AskedQuestion[] {
+  if (!body) return [];
+  const items: AskedQuestion[] = [];
+  let current: AskedQuestion | undefined;
+  for (const line of body.split("\n")) {
+    const match = /^(\s*)(?:\d+[.)]|[-*])\s+(.*\S)\s*$/.exec(line);
+    if (match && (match[1]!.length === 0 || !current)) {
+      current = { text: match[2]!.replace(/\*\*/g, ""), options: [] };
+      items.push(current);
+    } else if (match && current) {
+      current.options.push(parseOption(match[2]!));
+    } else if (line.trim() && current) {
+      const last = current.options.at(-1);
+      if (last) last.description = `${last.description} ${line.trim()}`.trim();
+      else current.text = `${current.text} ${line.trim()}`;
+    }
+  }
+  return items.map(inlineOptions);
+}
+
+/** A leading `[SEAT]` tag names who asked; the oracle uses it when it relays a seat. */
+function tagged(question: AskedQuestion, fallback: string): PanelQuestion {
+  const tag = /^\[(DEV|DESIGN|QA|RESEARCH|ORACLE)\]\s*/i.exec(question.text);
+  return tag ? { ...question, from: tag[1]!.toUpperCase(), text: question.text.slice(tag[0].length) } : { ...question, from: fallback };
+}
+
 /**
  * Read the oracle's reply. Missing sections degrade gracefully: no status
  * reads as grilling, and a reply with no sections at all becomes one question
@@ -147,8 +208,8 @@ export function parsePlannerReply(text: string): PlannerReply {
   const status = /\bready\b/i.test(parts.get("status") ?? "") ? "ready" : "grilling";
   const title = parts.get("title")?.split("\n").find((line) => line.trim())?.replace(/^[#*\s]+|[*\s]+$/g, "");
   const plan = parts.get("plan") ?? parts.get("draft plan");
-  let questions = listItems(parts.get("questions"));
-  if (parts.size === 0 && text.trim()) questions = [text.trim()];
+  let questions = questionItems(parts.get("questions"));
+  if (parts.size === 0 && text.trim()) questions = [{ text: text.trim(), options: [] }];
   return { status, questions, ...(title ? { title } : {}), ...(plan ? { plan } : {}) };
 }
 
@@ -156,13 +217,17 @@ export function parsePlannerReply(text: string): PlannerReply {
 export function parseMemberReply(text: string): MemberReply {
   const parts = sections(text);
   const ready = /\bready\b/i.test(parts.get("status") ?? "");
-  let questions = ready ? [] : listItems(parts.get("questions"));
-  if (parts.size === 0 && text.trim()) questions = [text.trim()];
+  let questions = ready ? [] : questionItems(parts.get("questions"));
+  if (parts.size === 0 && text.trim()) questions = [{ text: text.trim(), options: [] }];
   return { status: ready ? "ready" : "open", questions, notes: listItems(parts.get("notes")) };
 }
 
+function optionLines(options: readonly PanelOption[]): string[] {
+  return options.map((option) => `   - ${option.label}${option.description ? ` — ${option.description}` : ""}`);
+}
+
 function questionLine(question: PanelQuestion, index: number): string {
-  return `${index + 1}. [${question.from}] ${question.text}`;
+  return [`${index + 1}. [${question.from}] ${question.text}`, ...optionLines(question.options)].join("\n");
 }
 
 /** The conversation, the source issue and the current draft: what every seat and the oracle read. */
@@ -196,13 +261,26 @@ export function panelSection(outcomes: readonly MemberOutcome[]): string {
     const { status, questions, notes } = outcome.reply;
     return [
       `### ${label} — ${status === "ready" ? "READY" : "OPEN"}`,
-      questions.length > 0 ? `Questions asked of the user:\n${questions.map((question) => `- ${question}`).join("\n")}` : "",
+      questions.length > 0 ? `Questions for the user:\n${questions.map((question) => [`- ${question.text}`, ...optionLines(question.options)].join("\n")).join("\n")}` : "",
       notes.length > 0 ? `Notes:\n${notes.map((note) => `- ${note}`).join("\n")}` : "",
     ].filter(Boolean).join("\n");
   });
   return ["## Panel this round", "", ...blocks].join("\n\n");
 }
 
+/** A comment the user left on one line of the draft plan. */
+export interface LineComment {
+  /** The line as shown, without styling. */
+  line: string;
+  text: string;
+}
+
+/** Line comments as part of the user's next turn. */
+export function commentBlock(comments: readonly LineComment[]): string {
+  if (comments.length === 0) return "";
+  return ["Comments on the draft plan:", ...comments.map((comment) => `- On "${comment.line.replace(/\s+/g, " ").trim()}": ${comment.text.trim()}`)].join("\n");
+}
+
 /** What the panel said in a round, as the conversation shows it. */
 export function plannerSays(ready: boolean, questions: readonly PanelQuestion[]): string {
   if (ready) return "The panel agrees the plan is clear. Press s to save it as a pending task, or keep refining.";
@@ -250,6 +328,10 @@ export class PlanningSession {
   error?: string;
   turns = 0;
   saved?: PlannedTask;
+  /** Questionnaires answered so far for this round's questions, so stopping one resumes where it left off. */
+  answered: AskResult[] = [];
+  /** Comments on draft lines, sent with the user's next turn. */
+  lineComments: LineComment[] = [];
   private controller?: AbortController;
   private readonly deps: PlannerDeps;
   private readonly memberNotes = new Map<PanelMember, string[]>();
@@ -276,15 +358,36 @@ export class PlanningSession {
     return this.seats.has(member);
   }
 
-  /** Add the user's message (the idea, or answers) and run a round. */
+  /** Add the user's message (the idea, or answers), with any line comments, and run a round. */
   async send(text: string): Promise<void> {
-    const body = text.trim();
+    const body = [text.trim(), commentBlock(this.lineComments)].filter(Boolean).join("\n\n");
     if (!body) return;
     if (this.busy) throw new Error("the panel is still thinking");
+    this.lineComments = [];
     this.messages = [...this.messages, { role: "you", text: body, at: Date.now() }];
     await this.turn();
   }
 
+  /** The round's questions still wait for answers. */
+  get awaitingAnswers(): boolean {
+    return !this.busy && this.questions.length > 0;
+  }
+
+  /**
+   * Comment on one line of the draft. While questions wait for answers the
+   * comment rides along with them; otherwise it goes to the panel now.
+   * Returns whether a round started.
+   */
+  commentOnLine(line: string, text: string): boolean {
+    const body = text.trim();
+    if (!body || !line.trim()) return false;
+    this.lineComments = [...this.lineComments, { line: line.trim(), text: body }];
+    this.deps.onChange?.();
+    if (this.busy || this.awaitingAnswers) return false;
+    void this.send("");
+    return true;
+  }
+
   /** Start from the seed alone (an issue) without a user message. */
   async open(): Promise<void> {
     if (this.busy || this.messages.length > 0) return;
@@ -396,6 +499,7 @@ export class PlanningSession {
     this.status = "thinking";
     this.error = undefined;
     this.turns += 1;
+    this.answered = [];
     this.members = PANEL_MEMBERS.filter((member) => this.seats.has(member)).map((member) => ({ member, status: "thinking", step: "reading the conversation" }));
     this.step = this.members.length > 0 ? "waiting for the panel" : "reading the conversation";
     this.deps.onChange?.();
@@ -422,14 +526,17 @@ export class PlanningSession {
       this.controller = undefined;
       if (this.error) this.deps.feed?.log(ORACLE_LABEL, `planning round failed — ${this.error.split("\n")[0]}`, "error");
       this.deps.onChange?.();
+      this.deps.onRound?.(this);
     }
+    // Comments left on draft lines during the round go to the panel now, unless questions wait (they ride with the answers).
+    if (!this.error && !this.busy && this.questions.length === 0 && this.lineComments.length > 0) await this.send("");
   }
 
   /** Merge the seats' and the oracle's answers into the round's questions, verdict and draft. */
   private finishRound(outcomes: readonly MemberOutcome[], lead: RunOutcome): void {
     const reply = lead.status === "success" ? parsePlannerReply(lead.output) : undefined;
-    const seatQuestions = outcomes.flatMap((outcome) => (outcome.reply?.questions ?? []).map((text) => ({ from: MEMBER_LABELS[outcome.member], text })));
-    const questions = [...(reply?.questions ?? []).map((text) => ({ from: ORACLE_LABEL, text })), ...seatQuestions];
+    const seatQuestions = outcomes.flatMap((outcome) => (outcome.reply?.questions ?? []).map((question) => ({ ...question, from: MEMBER_LABELS[outcome.member] })));
+    const questions = [...(reply?.questions ?? []).map((question) => tagged(question, ORACLE_LABEL)), ...seatQuestions];
     const seatsReady = outcomes.every((outcome) => outcome.reply?.status === "ready");
     const ready = Boolean(reply && reply.status === "ready" && seatsReady);
     if (reply) {