@a-t-h-i/bot-lobby 0.6.3 → 0.6.5

package/src/lobby/tabs/home.ts

@@ -10,7 +10,7 @@ import type { Task } from "../../schemas/task.ts";
 import type { ActivityEntry, ChatEntry, ThoughtEntry } from "../feed.ts";
 import type { LobbyPanel } from "../../schemas/configuration.ts";
 import { markdownBlocks } from "../markdown.ts";
-import { beside, bold, box, clock, fill, fit, italic, markdownLines, notePane, paint, since, spinner, wrap, wrapHanging, type LobbyColor, type LobbyTheme, type PaneLayout } from "../layout.ts";
+import { beside, bold, box, clock, fill, fit, italic, markdownLines, notePane, paint, since, spinner, wrap, wrapHanging, type LobbyColor, type LobbyTheme, type PaneLayout, type PaneMark } from "../layout.ts";
 
 /** The Lobby tab's scrollable panes. */
 export const HOME_PANES = ["conversation", "activity", "thinking"] as const;
@@ -36,6 +36,8 @@ export interface HomeInput {
   focus?: HomePane;
   /** Filled with where each pane landed and how much it holds. */
   panes?: PaneLayout;
+  /** Each pane's newest entry as the frame before marked it, so the pane can measure what arrived below since. */
+  anchors?: ReadonlyMap<string, PaneMark>;
   tick: number;
   now: number;
   /** Which panes show. */
@@ -144,18 +146,20 @@ export function speakerLine(speaker: Speaker, width: number, theme?: LobbyTheme,
 
 /**
  * What you wrote: a bubble on the right, only as wide as its longest line (up
- * to `YOU_SHARE` of the pane), your words in the accent colour on pi's
- * user-message background — or, where the theme has no background, closed
- * by a bar in that colour.
+ * to `YOU_SHARE` of the pane), your words in Markdown as pi renders them, in
+ * the accent colour on pi's user-message background — or, where the theme
+ * has no background, closed by a bar in that colour.
  */
 export function youLines(text: string, width: number, theme?: LobbyTheme): string[] {
   const most = Math.max(1, messageWidth(width, YOU_SHARE, 4) - 2);
-  const lines = wrap(text, most);
+  // The renderer colours your words itself; without one (tests) they are wrapped and painted here.
+  const rendered = theme?.markdown ? markdownLines(text, most, theme, true, "you") : wrap(text, most).map((line) => paint(theme, "accent", line));
+  const lines = rendered.length > 0 ? rendered : [""];
   const inner = Math.max(1, ...lines.map((line) => textWidth(line)));
   const pad = " ".repeat(Math.max(0, width - inner - 2));
   const bubble = theme?.bg
-    ? (line: string) => theme.bg!("userMessageBg", ` ${fit(paint(theme, "accent", line), inner)} `)
-    : (line: string) => `${fit(paint(theme, "accent", line), inner)} ${paint(theme, "accent", "▐")}`;
+    ? (line: string) => theme.bg!("userMessageBg", ` ${fit(line, inner)} `)
+    : (line: string) => `${fit(line, inner)} ${paint(theme, "accent", "▐")}`;
   return lines.map((line) => `${pad}${bubble(line)}`);
 }
 
@@ -181,25 +185,19 @@ function openBlockLines(text: string, width: number, theme: LobbyTheme | undefin
 }
 
 /**
- * The newest `need` lines (or a few more) of the reply the oracle is still
- * writing. It is drawn block by block (see `markdownBlocks`): finished blocks
- * come from the Markdown cache, only the one being written is rendered on
- * each frame, and blocks above what the pane shows are not drawn at all.
+ * The reply the oracle is still writing. It is drawn block by block (see
+ * `markdownBlocks`): finished blocks come from the Markdown cache and only the
+ * one being written is rendered on each frame. It is drawn whole (it is
+ * capped at `MAX_REPLY_TEXT`), so the pane knows exactly how far it reaches.
  */
-function liveLines(text: string, width: number, theme: LobbyTheme | undefined, need: number): string[] {
+function liveLines(text: string, width: number, theme: LobbyTheme | undefined): string[] {
   const blocks = markdownBlocks(text);
-  const parts: string[][] = [];
-  let count = 0;
-  for (let index = blocks.length - 1; index >= 0 && count < need; index -= 1) {
-    const lines = index === blocks.length - 1 ? openBlockLines(blocks[index]!, width, theme) : oracleLines(blocks[index]!, width, theme);
-    if (lines.length === 0) continue;
-    parts.push(lines);
-    count += lines.length + 1;
-  }
   const lines: string[] = [];
-  for (let part = parts.length - 1; part >= 0; part -= 1) {
+  for (let index = 0; index < blocks.length; index += 1) {
+    const block = index === blocks.length - 1 ? openBlockLines(blocks[index]!, width, theme) : oracleLines(blocks[index]!, width, theme);
+    if (block.length === 0) continue;
     if (lines.length > 0) lines.push("");
-    for (const line of parts[part]!) lines.push(line);
+    for (const line of block) lines.push(line);
   }
   return lines;
 }
@@ -218,6 +216,20 @@ export function eventLines(text: string, at: number, width: number, theme?: Lobb
 export interface PaneLines {
   lines: string[];
   total: number;
+  /** The newest entry and how many lines run from its first line to the end, for the next frame to measure against. */
+  mark?: PaneMark;
+  /** Lines that arrived below the anchor passed in since it was marked; absent when it is no longer there. */
+  grew?: number;
+}
+
+/**
+ * Where the anchor (an entry the frame before marked) sits in `entries`, so
+ * drawing goes on at least that far back; `entries.length` when it is gone.
+ * It is nearly always the last entry, so the search from the end is short.
+ */
+function reachOf<T extends object>(entries: readonly T[], anchor: PaneMark | undefined): { found: number; reach: number } {
+  const found = anchor ? entries.lastIndexOf(anchor.entry as T) : -1;
+  return { found, reach: found < 0 ? entries.length : found };
 }
 
 /** A message's drawn lines, kept until the pane's width, the theme or its grouping changes. */
@@ -259,6 +271,18 @@ function entryBlock(entry: ChatEntry, before: ChatEntry | undefined, width: numb
   return lines;
 }
 
+export interface ChatTailOptions {
+  /** The reply the oracle is still writing. */
+  live?: string;
+  /** The oracle's turn is running. */
+  busy?: boolean;
+  tick?: number;
+  /** Tops a conversation that has earlier messages still to load. */
+  older?: string;
+  /** The newest message as the frame before marked it: drawing reaches at least back to it, to measure what arrived below. */
+  anchor?: PaneMark;
+}
+
 /**
  * The newest `need` lines of the conversation, like a chat: your messages as
  * bubbles on the right, the oracle's replies in Markdown on the left, each
@@ -269,7 +293,8 @@ function entryBlock(entry: ChatEntry, before: ChatEntry | undefined, width: numb
  * whole conversation has been drawn. `older` tops a conversation that has
  * earlier messages still to load.
  */
-export function chatTail(chat: readonly ChatEntry[], width: number, theme: LobbyTheme | undefined, need: number, live?: string, busy = false, tick = 0, older?: string): PaneLines {
+export function chatTail(chat: readonly ChatEntry[], width: number, theme: LobbyTheme | undefined, need: number, options: ChatTailOptions = {}): PaneLines {
+  const { live, busy = false, tick = 0, older, anchor } = options;
   const parts: string[][] = [];
   let count = 0;
   const add = (lines: string[]) => {
@@ -277,10 +302,18 @@ export function chatTail(chat: readonly ChatEntry[], width: number, theme: Lobby
     count += lines.length + (parts.length > 0 ? 1 : 0);
     parts.push(lines);
   };
-  if (live?.trim()) add([speakerLine("oracle", width, theme, `${spinner(tick)} writing`), ...liveLines(live.trim(), width, theme, need)]);
+  if (live?.trim()) add([speakerLine("oracle", width, theme, `${spinner(tick)} writing`), ...liveLines(live.trim(), width, theme)]);
   else if (busy) add([speakerLine("oracle", width, theme, `${spinner(tick)} working…`)]);
+  const { found, reach } = reachOf(chat, anchor);
+  let mark: PaneMark | undefined;
+  let grew: number | undefined;
   let index = chat.length - 1;
-  for (; index >= 0 && count < need; index -= 1) add(entryBlock(chat[index]!, chat[index - 1], width, theme));
+  for (; index >= 0 && (count < need || index >= reach); index -= 1) {
+    const entry = chat[index]!;
+    add(entryBlock(entry, chat[index - 1], width, theme));
+    if (index === chat.length - 1) mark = { entry, below: count };
+    if (index === found) grew = count - anchor!.below;
+  }
   const drawn = chat.length - 1 - index;
   if (index < 0 && older) add(wrap(paint(theme, "dim", older), width));
   const lines: string[] = [];
@@ -291,12 +324,12 @@ export function chatTail(chat: readonly ChatEntry[], width: number, theme: Lobby
   // Messages not drawn yet count at the average height of those that were.
   const rest = index + 1;
   const total = rest > 0 && drawn > 0 ? lines.length + Math.ceil((rest * lines.length) / drawn) : lines.length;
-  return { lines, total };
+  return { lines, total, ...(mark ? { mark } : {}), ...(grew !== undefined ? { grew } : {}) };
 }
 
 /** The whole conversation drawn (the session browser's preview and tests; the Lobby tab draws only what shows). */
 export function chatLines(chat: readonly ChatEntry[], width: number, theme?: LobbyTheme, live?: string, busy = false, tick = 0): string[] {
-  return chatTail(chat, width, theme, Number.POSITIVE_INFINITY, live, busy, tick).lines;
+  return chatTail(chat, width, theme, Number.POSITIVE_INFINITY, { ...(live ? { live } : {}), busy, tick }).lines;
 }
 
 function emptyChat(input: HomeInput, width: number, theme?: LobbyTheme): string[] {
@@ -334,19 +367,27 @@ function whole(lines: string[]): PaneLines {
   return { lines, total: lines.length };
 }
 
-function conversation(input: HomeInput, chat: readonly ChatEntry[], width: number, need: number, theme?: LobbyTheme): PaneLines {
+function conversation(input: HomeInput, chat: readonly ChatEntry[], width: number, need: number, anchor: PaneMark | undefined, theme?: LobbyTheme): PaneLines {
   const searching = Boolean(input.query);
   const live = searching ? undefined : input.liveReply;
   const busy = !searching && input.busy;
   if (chat.length === 0 && !live && !busy) return whole(emptyChat(input, width, theme));
-  return chatTail(chat, width, theme, need, live, busy, input.tick, searching ? undefined : input.olderNote);
+  const older = searching ? undefined : input.olderNote;
+  return chatTail(chat, width, theme, need, { ...(live ? { live } : {}), busy, tick: input.tick, ...(older ? { older } : {}), ...(anchor ? { anchor } : {}) });
 }
 
 /** The newest `need` activity lines (one per entry), drawn only as far back as the pane shows. */
-function activity(input: HomeInput, entries: readonly ActivityEntry[], width: number, need: number, theme?: LobbyTheme): PaneLines {
+function activity(input: HomeInput, entries: readonly ActivityEntry[], width: number, need: number, anchor: PaneMark | undefined, theme?: LobbyTheme): PaneLines {
   if (entries.length === 0) return whole(wrap(paint(theme, "dim", input.query ? `No activity matches "${input.query}".` : input.activityNote ?? "No activity yet."), width));
   const shown = Number.isFinite(need) ? entries.slice(-Math.max(0, need)) : entries;
-  return { lines: shown.map((entry) => activityLine(entry, width, input.tick, theme)), total: entries.length };
+  // One line per entry: where the anchor sits is a count, nothing needs drawing to find it.
+  const { found } = reachOf(entries, anchor);
+  return {
+    lines: shown.map((entry) => activityLine(entry, width, input.tick, theme)),
+    total: entries.length,
+    mark: { entry: entries.at(-1)!, below: 1 },
+    ...(found >= 0 ? { grew: entries.length - found - anchor!.below } : {}),
+  };
 }
 
 /** The last `rows` lines, `offset` lines back from the newest (clamped), and where they start. */
@@ -381,8 +422,9 @@ export function currentThought(thoughts: readonly ThoughtEntry[]): ThoughtEntry
  */
 const thoughtBlocks = new WeakMap<object, WeakMap<ThoughtEntry, { width: number; text: string; lines: string[]; at: number }>>();
 
-/** A live thought this long is wrapped again at most every `LONG_THOUGHT_MS` while it streams. */
+/** A live thought this long is wrapped again at most every `LONG_THOUGHT_MS` while it streams; rendered as Markdown (costlier), from `LONG_THOUGHT_MARKDOWN`. */
 const LONG_THOUGHT = 1000;
+const LONG_THOUGHT_MARKDOWN = 300;
 const LONG_THOUGHT_MS = 150;
 
 function thoughtBlock(thought: ThoughtEntry, width: number, theme?: LobbyTheme): string[] {
@@ -393,28 +435,49 @@ function thoughtBlock(thought: ThoughtEntry, width: number, theme?: LobbyTheme):
   }
   const hit = cache.get(thought);
   const now = performance.now();
-  if (hit && hit.width === width && (hit.text === thought.text || (thought.live && thought.text.length > LONG_THOUGHT && now - hit.at < LONG_THOUGHT_MS))) return hit.lines;
+  const long = theme?.markdown ? LONG_THOUGHT_MARKDOWN : LONG_THOUGHT;
+  if (hit && hit.width === width && (hit.text === thought.text || (thought.live && thought.text.length > long && now - hit.at < LONG_THOUGHT_MS))) return hit.lines;
   const lead = `${paint(theme, sourceColor(thought.source), thought.source.padEnd(SOURCE_WIDTH).slice(0, SOURCE_WIDTH))} `;
-  const lines = wrapHanging(lead, italic(theme, paint(theme, "dim", thought.text.replace(/\s*\n\s*/g, " "))), width);
+  const lines = theme?.markdown ? thoughtMarkdown(lead, thought, width, theme) : wrapHanging(lead, italic(theme, paint(theme, "dim", thought.text.replace(/\s*\n\s*/g, " "))), width);
   cache.set(thought, { width, text: thought.text, lines, at: now });
   return lines;
 }
 
-/** The newest `need` lines of the thoughts, oldest first: only the thoughts they reach are drawn, and the rest estimated. */
-export function thoughtTail(thoughts: readonly ThoughtEntry[], width: number, theme: LobbyTheme | undefined, need: number): PaneLines {
+/**
+ * A thought in Markdown as pi shows thinking (dimmed, in italics), after who
+ * thought it: a model's `**Checking the plan**` reads bold, not starred. The
+ * pane is small, so the blank lines between paragraphs are left out. A live
+ * thought is not kept in the renderer's cache; it changes as it streams.
+ */
+function thoughtMarkdown(lead: string, thought: ThoughtEntry, width: number, theme: LobbyTheme): string[] {
+  const indent = " ".repeat(textWidth(lead));
+  const body = markdownLines(thought.text, Math.max(1, width - textWidth(lead)), theme, !thought.live, "thought").filter((line) => line.trim());
+  if (body.length === 0) return [lead];
+  return body.map((line, index) => `${index === 0 ? lead : indent}${line}`);
+}
+
+/** The newest `need` lines of the thoughts, oldest first: only the thoughts they reach are drawn (and back to `anchor`), and the rest estimated. */
+export function thoughtTail(thoughts: readonly ThoughtEntry[], width: number, theme: LobbyTheme | undefined, need: number, anchor?: PaneMark): PaneLines {
   const parts: string[][] = [];
   let count = 0;
+  const { found, reach } = reachOf(thoughts, anchor);
+  let mark: PaneMark | undefined;
+  let grew: number | undefined;
   let index = thoughts.length - 1;
-  for (; index >= 0 && count < need; index -= 1) {
-    const lines = thoughtBlock(thoughts[index]!, width, theme);
+  for (; index >= 0 && (count < need || index >= reach); index -= 1) {
+    const thought = thoughts[index]!;
+    const lines = thoughtBlock(thought, width, theme);
     parts.push(lines);
     count += lines.length;
+    if (index === thoughts.length - 1) mark = { entry: thought, below: count };
+    if (index === found) grew = count - anchor!.below;
   }
   const lines: string[] = [];
   for (let part = parts.length - 1; part >= 0; part -= 1) for (const line of parts[part]!) lines.push(line);
   const rest = index + 1;
   const drawn = parts.length;
-  return { lines, total: rest > 0 && drawn > 0 ? lines.length + Math.ceil((rest * lines.length) / drawn) : lines.length };
+  const total = rest > 0 && drawn > 0 ? lines.length + Math.ceil((rest * lines.length) / drawn) : lines.length;
+  return { lines, total, ...(mark ? { mark } : {}), ...(grew !== undefined ? { grew } : {}) };
 }
 
 /** Every thought, oldest first: who thought it, then the thought, dimmed. */
@@ -422,8 +485,8 @@ export function thoughtLines(thoughts: readonly ThoughtEntry[], width: number, t
   return thoughtTail(thoughts, width, theme, Number.POSITIVE_INFINITY).lines;
 }
 
-function thinkingContent(input: HomeInput, thoughts: readonly ThoughtEntry[], width: number, need: number, theme?: LobbyTheme): PaneLines {
-  if (thoughts.length > 0) return thoughtTail(thoughts, width, theme, need);
+function thinkingContent(input: HomeInput, thoughts: readonly ThoughtEntry[], width: number, need: number, anchor: PaneMark | undefined, theme?: LobbyTheme): PaneLines {
+  if (thoughts.length > 0) return thoughtTail(thoughts, width, theme, need, anchor);
   return whole([paint(theme, "dim", input.query ? `No thought matches "${input.query}".` : "Thoughts from the oracle and every agent appear here, and only here.")]);
 }
 
@@ -482,23 +545,24 @@ export function renderHome(input: HomeInput, width: number, height: number, them
   const matches = (count: number) => `${count} match${count === 1 ? "" : "es"}`;
   /**
    * One scrollable pane: only the lines it shows are drawn — its newest, or
-   * as far back as it is scrolled — in a box that records where it sits.
+   * as far back as it is scrolled — in a box that records where it sits, and
+   * how many lines arrived below since the frame before.
    */
-  const pane = (name: HomePane, title: string, note: string | undefined, content: (inner: number, need: number) => PaneLines) => (top: number, left: number, w: number, h: number): string[] => {
+  const pane = (name: HomePane, title: string, note: string | undefined, content: (inner: number, need: number, anchor: PaneMark | undefined) => PaneLines) => (top: number, left: number, w: number, h: number): string[] => {
     const rows = Math.max(0, h - 2);
     const offset = input.offsets?.[name] ?? 0;
-    const drawn = content(Math.max(1, w - 4), rows + offset);
+    const drawn = content(Math.max(1, w - 4), rows + offset, input.anchors?.get(name));
     const view = paneWindow(drawn, rows, offset);
     const total = Math.max(drawn.total, drawn.lines.length);
-    notePane(input.panes, name, top, left, w, h, total);
+    notePane(input.panes, name, top, left, w, h, total, { ...(drawn.mark ? { mark: drawn.mark } : {}), grew: drawn.grew ?? 0 });
     const right = rightNote(view.offset, note);
     return box(w, h, view.shown, { title, ...(right ? { right } : {}), focused: input.focus === name, scroll: { total, start: view.start }, theme });
   };
-  const chatBox = pane("conversation", input.title ? `Conversation · ${input.title}` : "Conversation", input.query ? matches(feed.chat.length) : input.keys?.conversation, (inner, need) => conversation(input, feed.chat, inner, need, theme));
-  const activityBox = pane("activity", "Activity", input.query ? matches(feed.activity.length) : input.keys?.activity, (inner, need) => activity(input, feed.activity, inner, need, theme));
+  const chatBox = pane("conversation", input.title ? `Conversation · ${input.title}` : "Conversation", input.query ? matches(feed.chat.length) : input.keys?.conversation, (inner, need, anchor) => conversation(input, feed.chat, inner, need, anchor, theme));
+  const activityBox = pane("activity", "Activity", input.query ? matches(feed.activity.length) : input.keys?.activity, (inner, need, anchor) => activity(input, feed.activity, inner, need, anchor, theme));
   const thought = currentThought(feed.thoughts);
   const thinkingNote = thought ? `${thought.source} · ${thought.live ? "thinking" : since(input.now - thought.at)}` : input.keys?.thinking;
-  const thinkingBox = pane("thinking", "Thinking", thinkingNote, (inner, need) => thinkingContent(input, feed.thoughts, inner, need, theme));
+  const thinkingBox = pane("thinking", "Thinking", thinkingNote, (inner, need, anchor) => thinkingContent(input, feed.thoughts, inner, need, anchor, theme));
   const top = scene.length;
   let body: string[] = [];
   if (main > 0 && panels.conversation && panels.activity) {

package/src/lobby/tabs/issues.ts

@@ -4,7 +4,7 @@
  * becomes a task.
  */
 import type { IssueDetail, IssueSummary } from "../issues.ts";
-import { bold, since, columns, fill, paint, rule, selectRow, spinner, split, windowStart, wrap, type LobbyTheme } from "../layout.ts";
+import { bold, since, columns, fill, markdownLines, paint, rule, selectRow, spinner, split, windowStart, wrap, type LobbyTheme } from "../layout.ts";
 
 export interface IssuesTabInput {
   issues: readonly IssueSummary[];
@@ -31,9 +31,10 @@ export function issueDetailLines(issue: IssueDetail, width: number, now: number,
   ].filter(Boolean);
   const lines = [...wrap(bold(theme, `#${issue.number} ${issue.title}`), width), facts.join(paint(theme, "dim", " · "))];
   if (issue.url) lines.push(paint(theme, "dim", issue.url));
-  lines.push("", paint(theme, "dim", "p plans it with the planning panel, then save it as a task"), "", ...wrap(issue.body.trim() || paint(theme, "dim", "(no description)"), width));
+  // Issues and their comments are GitHub Markdown.
+  lines.push("", paint(theme, "dim", "p plans it with the planning panel, then save it as a task"), "", ...(issue.body.trim() ? markdownLines(issue.body.trim(), width, theme) : [paint(theme, "dim", "(no description)")]));
   for (const comment of issue.comments) {
-    lines.push("", rule(width, comment.author ?? "comment", theme, comment.createdAt ? since(now - Date.parse(comment.createdAt)) : ""), ...wrap(comment.body.trim(), width));
+    lines.push("", rule(width, comment.author ?? "comment", theme, comment.createdAt ? since(now - Date.parse(comment.createdAt)) : ""), ...markdownLines(comment.body.trim(), width, theme));
   }
   return lines;
 }

package/src/lobby/tabs/plan.ts

@@ -9,7 +9,7 @@
 import { stripTerminalSequences } from "@earendil-works/pi-tui";
 import { ORACLE_LABEL, type LineComment, type PanelNote, type PanelQuestion, type PlannerMessage, type PlannerReply, type PlannerSeed, type RoundMode } from "../planner.ts";
 import type { PlannedTask } from "../../state/backlog.ts";
-import { beside, bold, box, clock, fill, fit, italic, markdownLines, notePane, paint, selectRow, spinner, wrap, wrapHanging, type LobbyTheme, type PaneLayout } from "../layout.ts";
+import { beside, bold, box, clock, fill, fit, italic, markdownHanging, markdownLines, notePane, paint, selectRow, spinner, wrap, wrapHanging, type LobbyTheme, type PaneLayout } from "../layout.ts";
 import { sourceColor, speakerLine, tailWindow, youLines } from "./home.ts";
 
 export interface SeatView {
@@ -152,7 +152,7 @@ function questionLines(questions: ReadonlyArray<{ question: PanelQuestion; numbe
     const lead = `${paint(theme, "dim", `${String(number).padStart(2)}.`)} ${bold(theme, paint(theme, sourceColor(question.from), question.from.padEnd(LABEL_WIDTH)))} `;
     const indent = " ".repeat(4 + LABEL_WIDTH);
     const options = question.options.map((option) => wrapHanging(`${indent}${paint(theme, "dim", "○")} `, `${option.label}${option.description ? paint(theme, "dim", ` — ${option.description}`) : ""}`, width)).flat();
-    return [...wrapHanging(lead, question.text, width), ...options];
+    return [...markdownHanging(lead, question.text, width, theme), ...options];
   });
 }
 
@@ -178,7 +178,7 @@ export function conversationLines(view: PlanView, width: number, theme?: LobbyTh
       continue;
     }
     lines.push(speakerLine("panel", width, theme, time));
-    lines.push(...(questions.length > 0 ? questionLines(questions, width, theme) : wrap(message.text, width).map((line) => (line ? `  ${line}` : ""))));
+    lines.push(...(questions.length > 0 ? questionLines(questions, width, theme) : markdownLines(message.text, Math.max(1, width - 2), theme).map((line) => (line ? `  ${line}` : ""))));
     for (const entry of message.decided ?? []) {
       lines.push(...wrapHanging(`  ${paint(theme, "success", "✓")} `, `${paint(theme, sourceColor(entry.from), `[${entry.from}]`)} ${entry.question} → ${bold(theme, entry.answer)} ${paint(theme, "dim", `· decided by the classifier (${entry.probability.toFixed(2)}); comment on the plan to overrule`)}`, width));
     }
@@ -210,7 +210,7 @@ export function draftLines(view: PlanView, width: number, theme?: LobbyTheme): D
   }
   if (view.notes.length > 0) {
     lines.push(line(""), line(bold(theme, paint(theme, "mdHeading", "What each seat needs"))));
-    for (const note of view.notes) for (const wrapped of wrapHanging(`${paint(theme, sourceColor(note.from), note.from.padEnd(LABEL_WIDTH))} `, note.text, width)) lines.push(line(wrapped));
+    for (const note of view.notes) for (const wrapped of markdownHanging(`${paint(theme, sourceColor(note.from), note.from.padEnd(LABEL_WIDTH))} `, note.text, width, theme)) lines.push(line(wrapped));
   }
   return lines;
 }

package/src/lobby/tabs/quickfix.ts

@@ -61,15 +61,21 @@ export function jobDetailLines(job: QuickFixJob, width: number, tick: number, no
     job.tools ? `${job.tools} tool${job.tools === 1 ? "" : "s"}` : "",
     job.usage?.cost ? `$${job.usage.cost.toFixed(2)}` : "",
   ].filter(Boolean);
-  const lines = [paint(theme, "dim", job.id), facts.join(paint(theme, "dim", " · ")), "", ...wrap(bold(theme, job.prompt), width)];
+  // What you asked, in Markdown as your messages read in the conversation (a pasted snippet, a list of steps).
+  const asked = theme?.markdown ? markdownLines(job.prompt, width, theme, true, "you") : wrap(bold(theme, job.prompt), width);
+  const lines = [paint(theme, "dim", job.id), facts.join(paint(theme, "dim", " · ")), "", ...asked];
   if (job.route) lines.push("", ...wrap(paint(theme, "dim", `↓ routed ${job.route}`), width));
-  if (job.note) lines.push("", ...wrap(paint(theme, "warning", job.status === "held" ? `‖ Held: ${job.note}. r runs it anyway · t starts it as a task in a new session.` : job.note), width));
+  if (job.note) lines.push("", ...wrap(paint(theme, job.status === "held" ? "warning" : job.routed ? "muted" : "warning", job.status === "held" ? `‖ Held: ${job.note}. r runs it anyway · t starts it as a task in a new session.` : job.note), width));
   lines.push("", rule(width, "Steps", theme));
   if (job.steps.length === 0) lines.push(paint(theme, "dim", job.status === "queued" ? "Waiting for the quick fix ahead of it." : job.status === "running" ? `${spinner(tick)} starting…` : job.status === "held" ? "Not started." : "No tool calls."));
   for (const step of job.steps) {
     const lead = `${paint(theme, "dim", clock(step.at))} ${step.pending && job.status === "running" ? paint(theme, "accent", spinner(tick)) : paint(theme, "dim", "·")} `;
     lines.push(...wrapHanging(lead, step.pending && job.status === "running" ? `${step.text}…` : paint(theme, "muted", step.text), width));
   }
+  if (job.files?.length) {
+    lines.push("", rule(width, "Edited", theme));
+    for (const file of job.files) lines.push(...wrapHanging(paint(theme, "dim", "· "), paint(theme, "muted", file), width));
+  }
   if (job.error) lines.push("", ...wrap(paint(theme, "error", `✗ ${job.error}`), width));
   if (job.report) {
     lines.push("", rule(width, "Report", theme), ...markdownLines(job.report, width, theme));

package/src/lobby/tabs/tasks.ts

@@ -11,7 +11,8 @@ import { planChecklist } from "../../pi/zen.ts";
 import { persistedRuns } from "../../pi/ui.ts";
 import { describeRun, runFromLog } from "../../pi/run-summary.ts";
 import { pendingApprovals } from "../../workflow/approvals.ts";
-import { ago, beside, bold, box, detailWindow, fill, markdownLines, notePane, paint, position, rule, selectRow, since, spread, strike, windowStart, wrap, wrapHanging, type LobbyColor, type LobbyTheme, type PaneLayout } from "../layout.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";
 
 export type TaskSection = "mine" | "others" | "pending" | "recent" | "archived";
 
@@ -240,6 +241,13 @@ export function listCount(rows: readonly TaskRow[], query?: string): string {
 const COMMENT_MARKS: Record<PlanComment["status"], string> = { open: "○", delivered: "◐", addressed: "✓" };
 const COMMENT_WORDS: Record<PlanComment["status"], string> = { open: "waiting for the owning session", delivered: "sent to the oracle", addressed: "plan amended" };
 
+/** `note` at the end of the last line when it fits there, else on a line of its own under it. */
+function trailing(lines: string[], note: string, width: number): string[] {
+  const last = lines.at(-1) ?? "";
+  if (textWidth(last) + 1 + textWidth(note) <= width) return [...lines.slice(0, -1), `${last} ${note}`];
+  return [...lines, ...wrapHanging("  ", note, width)];
+}
+
 function section(title: string, width: number, theme?: LobbyTheme, right = ""): string[] {
   return ["", rule(width, title, theme, right)];
 }
@@ -260,7 +268,8 @@ export function taskDetailLines(task: Task, comments: readonly PlanComment[], se
     finished ? paint(theme, "muted", `${task.state === "abandoned" ? "dropped" : "done"} ${since(now - Date.parse(task.updatedAt))}`) : "",
   ].filter(Boolean);
   lines.push(...wrapHanging("  ", facts.join(dot), width));
-  lines.push(...wrapHanging("  ", paint(theme, "dim", [task.id, task.domains.length > 0 ? task.domains.join(", ") : ""].filter(Boolean).join(" · ")), 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));
   const steps = task.plan ? planChecklist(task.plan, persistedRuns(task)) : [];
   const done = steps.filter((step) => step.status === "done").length;
   if (steps.length > 0) {
@@ -268,7 +277,8 @@ export function taskDetailLines(task: Task, comments: readonly PlanComment[], se
     lines.push("", `  ${pips(done, steps.length, cells, theme)} ${paint(theme, "muted", `${done} of ${steps.length} steps`)}`);
   }
   const request = taskRequest(task);
-  if (request && request !== task.title) lines.push(...section("Request", width, theme), ...wrap(paint(theme, "muted", request), width));
+  // Requests are often Markdown: a plan agreed in the planning panel, an issue, a pasted spec.
+  if (request && request !== task.title) lines.push(...section("Request", width, theme), ...markdownLines(request, width, theme));
   if (task.plan) {
     if (steps.length > 0) {
       lines.push(...section("Progress", width, theme, `${done}/${steps.length} steps`));
@@ -291,11 +301,12 @@ export function taskDetailLines(task: Task, comments: readonly PlanComment[], se
   if (comments.length === 0) lines.push(paint(theme, "dim", TERMINAL_STATES.includes(task.state) ? "No comments." : "No comments yet — press c to comment on the plan; the oracle amends it."));
   for (const comment of comments) {
     const color = comment.status === "addressed" ? "success" : comment.status === "delivered" ? "accent" : "warning";
-    lines.push(...wrapHanging(`${paint(theme, color, COMMENT_MARKS[comment.status])} `, `${comment.text} ${paint(theme, "dim", `— ${COMMENT_WORDS[comment.status]}, ${since(now - Date.parse(comment.createdAt))}`)}`, width));
+    const said = markdownHanging(`${paint(theme, color, COMMENT_MARKS[comment.status])} `, comment.text, width, theme);
+    lines.push(...trailing(said, paint(theme, "dim", `— ${COMMENT_WORDS[comment.status]}, ${since(now - Date.parse(comment.createdAt))}`), width));
   }
   if (task.amendments.length > 0) {
     lines.push(...section("Amendments", width, theme));
-    for (const amendment of task.amendments) lines.push(...wrapHanging("- ", amendment, width));
+    for (const amendment of task.amendments) lines.push(...markdownHanging("- ", amendment, width, theme));
   }
   const approvals = pendingApprovals(task);
   if (approvals.length > 0 || task.blockers.length > 0) {

package/src/lobby/theme.ts

@@ -0,0 +1,30 @@
+/**
+ * pi's theme as bot-lobby draws with it (the lobby, the questionnaire), plus
+ * Markdown rendering; one wrapper (and one Markdown renderer with its cache)
+ * per theme, so caches stay warm and a theme switch starts fresh.
+ */
+import { getMarkdownTheme, type Theme } from "@earendil-works/pi-coding-agent";
+import type { LobbyTheme } from "./layout.ts";
+import { createMarkdownRenderer } from "./markdown.ts";
+
+const lobbyThemes = new WeakMap<Theme, LobbyTheme>();
+
+export function lobbyTheme(theme: Theme): LobbyTheme {
+  let wrapped = lobbyThemes.get(theme);
+  if (!wrapped) {
+    wrapped = {
+      fg: (color, text) => theme.fg(color, text),
+      bold: (text) => theme.bold(text),
+      italic: (text) => theme.italic(text),
+      bg: (color, text) => theme.bg(color, text),
+      // The same looks pi gives your messages and the thinking it shows.
+      markdown: createMarkdownRenderer(getMarkdownTheme(), {
+        you: { color: (text) => theme.fg("accent", text) },
+        thought: { color: (text) => theme.fg("thinkingText", text), italic: true },
+      }),
+      strike: (text) => theme.strikethrough(text),
+    };
+    lobbyThemes.set(theme, wrapped);
+  }
+  return wrapped;
+}

package/src/lobby/view.ts

@@ -23,7 +23,7 @@ import type { QuickFixQueue } from "./quickfix.ts";
 import { MEMBER_LABELS, ORACLE_LABEL, type PlannerSeed, type PlanningSession } from "./planner.ts";
 import { issueText, type IssuesState } from "./issues.ts";
 import { actionFor, keyLabel, keyMap, LOBBY_ACTIONS, type KeyMap, type LobbyAction } from "./keys.ts";
-import { beside, bold, box, fit, highlight, paint, rule, selectRow, spinner, spread, windowStart, wrap, wrapHanging, type LobbyTheme, type PaneLayout } from "./layout.ts";
+import { beside, bold, box, fit, highlight, paint, rule, selectRow, spinner, spread, windowStart, wrap, wrapHanging, type LobbyTheme, type PaneBox, type PaneLayout, type PaneMark } from "./layout.ts";
 import { chatTail, HOME_PANES, renderHome, type HomePane } from "./tabs/home.ts";
 import { filterRows, pips, planDetailLines, renderTasks, taskDetailLines, taskProgress, taskRows, tasksWidths, type TaskRow } from "./tabs/tasks.ts";
 import { renderPlan, type PlanLayout, type PlanView, type SeatView } from "./tabs/plan.ts";
@@ -320,6 +320,8 @@ export class LobbyView implements Component, Focusable {
   homeFocus: HomePane = "conversation";
   /** How many lines each pane held last frame, so a pane scrolled back stays on what you are reading as lines arrive. */
   private readonly seenTotals = new Map<string, number>();
+  /** Each Lobby pane's newest entry last frame: those panes measure what arrived below it, as their totals are estimates. */
+  private readonly marks = new Map<string, PaneMark>();
   /** Where the current tab's scrollable panes landed in the last frame. */
   private readonly panes: PaneLayout = new Map();
   private tasksSelected = 0;
@@ -469,6 +471,15 @@ export class LobbyView implements Component, Focusable {
     return visibleTabs(this.issuesOn);
   }
 
+  /** Open the Quick fix tab on a job the oracle routed there, with a line saying so. */
+  showQuickFix(id: string): void {
+    this.setTab("quickfix");
+    delete this.queries.quickfix;
+    this.fixSelected = Math.max(0, this.fixJobs().findIndex((job) => job.id === id));
+    this.fixDetailOffset = 0;
+    this.say(`${id} — the oracle sent your request to the quick-fix agent`);
+  }
+
   setTab(tab: TabId): void {
     if (tab === this.tab) return;
     if (!this.tabs().includes(tab)) return this.say(`the ${TAB_LABELS[tab]} tab is off — set lobby.${tab} to true in the config to bring it back`, "warning");
@@ -894,11 +905,10 @@ export class LobbyView implements Component, Focusable {
     const limit = (name: string, offset: number, anchored: boolean): number => {
       const pane = this.panes.get(name);
       if (!pane) return offset;
-      const seen = this.seenTotals.get(name);
-      this.seenTotals.set(name, pane.total);
+      const grew = this.grewBelow(name, pane);
       let next = offset;
-      if (anchored && next > 0 && seen !== undefined && pane.total > seen) {
-        next += pane.total - seen;
+      if (anchored && next > 0 && grew > 0) {
+        next += grew;
         moved = true;
       }
       return Math.min(next, Math.max(0, pane.total - pane.rows));
@@ -922,6 +932,25 @@ export class LobbyView implements Component, Focusable {
     return moved;
   }
 
+  /**
+   * Lines that arrived below a pane since it was last looked at, counted once.
+   * A pane that measures them from its newest entry says so; for the others
+   * (their totals exact) the total's growth stands in. An estimated total also
+   * moves as scrolling draws more or fewer of the entries it estimates, and
+   * following that pinned a pane scrolled to its top there.
+   */
+  private grewBelow(name: string, pane: PaneBox): number {
+    const seen = this.seenTotals.get(name);
+    this.seenTotals.set(name, pane.total);
+    const follow = pane.follow;
+    if (!follow) return seen === undefined ? 0 : pane.total - seen;
+    if (follow.mark) this.marks.set(name, follow.mark);
+    else this.marks.delete(name);
+    const grew = follow.grew;
+    follow.grew = 0;
+    return grew;
+  }
+
   /** Move the draft cursor by `delta` lines, skipping blank ones, and keep it on screen. */
   private moveCursor(delta: number): void {
     const lines = this.planLayout.draftText;
@@ -2276,6 +2305,7 @@ export class LobbyView implements Component, Focusable {
       others,
       pending: this.data.plans.filter((plan) => plan.status === "pending").length,
       offsets: this.homeOffsets,
+      anchors: this.marks,
       ...(this.mode === "browse" ? { focus: this.homeFocus } : {}),
       panes: this.panes,
       tick: this.tick,
@@ -2306,6 +2336,7 @@ export class LobbyView implements Component, Focusable {
       others: 0,
       pending: 0,
       offsets: this.homeOffsets,
+      anchors: this.marks,
       ...(this.mode === "browse" ? { focus: this.homeFocus } : {}),
       panes: this.panes,
       tick: this.tick,

package/src/master/decisions.ts

@@ -2,12 +2,20 @@ import type { Decision, Task, Verdict } from "../schemas/task.ts";
 import type { Domain } from "../schemas/agent.ts";
 import type { ScoutOutcome } from "./master.ts";
 import { detectGaps, domainsInvolved } from "./synthesis.ts";
+import { builtSomething, onFastTrack, qaRequired, qaTookPart } from "../workflow/track.ts";
 
-/** §19: everything the engine requires before completion may be declared. */
+/**
+ * §19: everything the engine requires before completion may be declared. The
+ * fast track asks for a finished worker step instead of a QA pass, and for
+ * QA's part only when the change needs tests.
+ */
 export function completionBlockers(task: Task, pendingCount: number): string[] {
   const blockers: string[] = [];
   if (!task.plan) blockers.push("no approved plan is recorded");
-  if (task.qaVerdict !== "pass") blockers.push(`QA gate is ${task.qaVerdict ?? "not run"}`);
+  if (onFastTrack(task)) {
+    if (!builtSomething(task)) blockers.push("no worker step has finished yet");
+    if (qaRequired(task) && !qaTookPart(task) && !task.qaWaiver) blockers.push("QA has not taken part (give qa the tests as the last step, or run the QA gate)");
+  } else if (task.qaVerdict !== "pass" && !task.qaWaiver) blockers.push(`QA gate is ${task.qaVerdict ?? "not run"}`);
   if (pendingCount > 0) blockers.push(`${pendingCount} unresolved approval request(s)`);
   if (task.blockers.length > 0) blockers.push(`${task.blockers.length} unresolved blocker(s)`);
   return blockers;