@a-t-h-i/bot-lobby 0.6.2 → 0.6.4

package/src/lobby/feed.ts

@@ -7,6 +7,7 @@
  */
 import type { AgentRun } from "../schemas/findings.ts";
 import { agentName } from "../pi/run-summary.ts";
+import { markdownBlocks } from "./markdown.ts";
 
 export type ActivityKind = "info" | "success" | "warning" | "error";
 
@@ -43,9 +44,12 @@ export interface ChatEntry {
 
 export const MAX_ACTIVITY = 400;
 export const MAX_THOUGHTS = 40;
-export const MAX_CHAT = 200;
+/** Messages the conversation keeps in memory; earlier ones are loaded from the session when scrolled to. */
+export const MAX_CHAT = 100;
 /** Longest thought kept; a streaming thought keeps its newest text. */
 export const MAX_THOUGHT_TEXT = 4000;
+/** The streaming reply kept: several panes' worth; past it, whole blocks are dropped from its start. */
+export const MAX_REPLY_TEXT = 8000;
 
 function bounded<T>(list: T[], max: number): T[] {
   return list.length > max ? list.slice(-max) : list;
@@ -57,6 +61,8 @@ export class LobbyFeed {
   chat: ChatEntry[] = [];
   /** The oracle's reply while it streams; cleared when the message ends. */
   reply = "";
+  /** Earlier messages than `chat` holds exist in the session (loaded only when scrolled back to). */
+  chatOlder = false;
   version = 0;
   private nextId = 1;
   private readonly listeners = new Set<() => void>();
@@ -90,16 +96,22 @@ export class LobbyFeed {
 
   /** A one-off entry that is already done (a receipt, a transition, a note). */
   log(source: string, text: string, kind: ActivityKind = "info", at = Date.now()): void {
-    this.activity = bounded([...this.activity, { id: this.nextId++, at, source, text, kind, pending: false }], MAX_ACTIVITY);
+    this.pushActivity({ id: this.nextId++, at, source, text, kind, pending: false });
     this.touch();
   }
 
   /** Open an in-flight step; `key` lets `end` settle exactly this one. */
   begin(source: string, text: string, key?: string, at = Date.now()): void {
-    this.activity = bounded([...this.activity, { id: this.nextId++, at, source, text, kind: "info", pending: true, ...(key ? { key } : {}) }], MAX_ACTIVITY);
+    this.pushActivity({ id: this.nextId++, at, source, text, kind: "info", pending: true, ...(key ? { key } : {}) });
     this.touch();
   }
 
+  /** Append in place (a busy agent logs many steps a second), dropping the oldest past the limit. */
+  private pushActivity(entry: ActivityEntry): void {
+    this.activity.push(entry);
+    if (this.activity.length > MAX_ACTIVITY) this.activity.splice(0, this.activity.length - MAX_ACTIVITY);
+  }
+
   /** Settle the step opened with `key`; an error marks it. */
   end(key: string, isError = false): void {
     if (this.settle(undefined, key, isError ? "error" : undefined)) this.touch();
@@ -116,7 +128,7 @@ export class LobbyFeed {
     const last = this.thoughts.at(-1);
     if (last && last.live && last.source === source) {
       const text = last.text + delta;
-      last.text = text.length > MAX_THOUGHT_TEXT ? text.slice(-MAX_THOUGHT_TEXT) : text;
+      last.text = text.length > MAX_THOUGHT_TEXT ? trimThought(text) : text;
     } else {
       this.thoughts = bounded([...this.thoughts, { id: this.nextId++, at, source, text: delta.slice(-MAX_THOUGHT_TEXT), live: true }], MAX_THOUGHTS);
     }
@@ -146,7 +158,7 @@ export class LobbyFeed {
 
   /** Stream the oracle's reply text as it arrives. */
   replyDelta(delta: string): void {
-    this.reply = (this.reply + delta).slice(-MAX_THOUGHT_TEXT);
+    this.reply = trimReply(this.reply + delta);
     this.touch();
   }
 
@@ -160,13 +172,19 @@ export class LobbyFeed {
   say(role: ChatRole, text: string, at = Date.now()): void {
     const body = text.trim();
     if (!body) return;
-    this.chat = bounded([...this.chat, { id: this.nextId++, at, role, text: body }], MAX_CHAT);
+    this.chat.push({ id: this.nextId++, at, role, text: body });
+    if (this.chat.length > MAX_CHAT) {
+      this.chat.splice(0, this.chat.length - MAX_CHAT);
+      this.chatOlder = true;
+    }
     this.touch();
   }
 
-  /** Replace the conversation (seeding from the session when the lobby first opens). */
+  /** Replace the conversation (seeding from the session when the lobby first opens); only the newest `MAX_CHAT` are kept. */
   seedChat(entries: ReadonlyArray<{ role: ChatRole; text: string; at?: number }>): void {
-    this.chat = bounded(entries.filter((entry) => entry.text.trim()).map((entry) => ({ id: this.nextId++, at: entry.at ?? 0, role: entry.role, text: entry.text.trim() })), MAX_CHAT);
+    const kept = entries.filter((entry) => entry.text.trim());
+    this.chatOlder = kept.length > MAX_CHAT;
+    this.chat = kept.slice(-MAX_CHAT).map((entry) => ({ id: this.nextId++, at: entry.at ?? 0, role: entry.role, text: entry.text.trim() }));
     this.touch();
   }
 
@@ -202,6 +220,7 @@ export class LobbyFeed {
     this.activity = [];
     this.thoughts = [];
     this.chat = [];
+    this.chatOlder = false;
     this.reply = "";
     this.runSteps.clear();
     this.runThoughts.clear();
@@ -210,6 +229,38 @@ export class LobbyFeed {
   }
 }
 
+/** A streaming thought past `MAX_THOUGHT_TEXT` cut to three quarters of it from a word's start, so its start then holds still a while. */
+function trimThought(text: string): string {
+  const cut = text.slice(-Math.floor(MAX_THOUGHT_TEXT * 0.75));
+  const space = cut.search(/\s/);
+  return space >= 0 && space < 80 ? cut.slice(space + 1) : cut;
+}
+
+/**
+ * A streaming reply past `max` characters cut down to three quarters of that
+ * (so its start then holds still for a while) by dropping whole Markdown
+ * blocks from its start, so what is left renders as it did (a cut inside a
+ * code block would turn the rest of the reply inside out). A single block
+ * longer than that keeps its end, and its opening fence if it is code.
+ */
+export function trimReply(text: string, max = MAX_REPLY_TEXT): string {
+  if (text.length <= max) return text;
+  const target = Math.floor(max * 0.75);
+  const blocks = markdownBlocks(text);
+  let length = text.length;
+  let first = 0;
+  // Each dropped block takes the blank line after it too.
+  while (first < blocks.length - 1 && length > target) length -= blocks[first++]!.length + 2;
+  if (length <= target) return blocks.slice(first).join("\n\n");
+  const last = blocks.at(-1) ?? text;
+  const opener = /^ {0,3}(?:`{3,}|~{3,}).*\n/.exec(last)?.[0] ?? "";
+  const rest = last.slice(opener.length);
+  const cut = rest.slice(-(target - opener.length));
+  // From a line start, so no line (or code) is shown half cut.
+  const line = cut.indexOf("\n");
+  return `${opener}${line >= 0 && line < cut.length - 1 ? cut.slice(line + 1) : cut}`;
+}
+
 /** The process-wide lobby feed; the Master session is the only writer that matters. */
 export const lobbyFeed = new LobbyFeed();
 
@@ -240,11 +291,28 @@ export function chatText(role: "user" | "assistant", text: string): Array<{ role
   return [{ role: "you", text: body }];
 }
 
+/** The session entry bot-lobby leaves where the oracle's context starts over (see pi/fresh-context.ts). */
+export const CONTEXT_MARK = "bot-lobby-context";
+
+/** What the conversation shows where a task's end cleared the oracle's context. */
+export const CLEARED_NOTE = "context cleared · the next request starts fresh";
+
+/** Whether a session entry is where a finished task cleared the oracle's context. */
+export function isClearedMark(entry: unknown): boolean {
+  const record = entry as { type?: string; customType?: string; data?: { kind?: unknown } } | undefined;
+  return record?.type === "custom" && record.customType === CONTEXT_MARK && record.data?.kind === "end";
+}
+
 /** Session entries (`{ type: "message", message }`) as conversation entries, oldest first. */
 export function chatFromEntries(entries: readonly unknown[], max = MAX_CHAT): Array<{ role: ChatRole; text: string; at?: number }> {
   const chat: Array<{ role: ChatRole; text: string; at?: number }> = [];
   for (const entry of entries) {
     const record = entry as { type?: string; timestamp?: string; message?: { role?: string; content?: unknown } };
+    if (isClearedMark(entry)) {
+      const at = record.timestamp ? Date.parse(record.timestamp) : Number.NaN;
+      chat.push({ role: "note", text: CLEARED_NOTE, ...(Number.isFinite(at) ? { at } : {}) });
+      continue;
+    }
     if (record?.type !== "message") continue;
     const role = record.message?.role;
     if (role !== "user" && role !== "assistant") continue;

package/src/lobby/layout.ts

@@ -4,7 +4,9 @@
  * its widths and heights explicitly and never reads a clock or the terminal,
  * so each tab renders deterministically in tests.
  */
-import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { truncateToWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { textWidth } from "../width.ts";
+import type { MarkdownStyle } from "./markdown.ts";
 
 /** Colours the lobby uses; a subset of pi's theme so tests can pass a plain stub. */
 export type LobbyColor =
@@ -28,8 +30,8 @@ export interface LobbyTheme {
   bold(text: string): string;
   italic?(text: string): string;
   bg?(color: "selectedBg" | "searchMatchBg" | "userMessageBg", text: string): string;
-  /** Render Markdown to styled lines; plain wrapping without it (tests). */
-  markdown?(text: string, width: number): string[];
+  /** Render Markdown to styled lines, in the look of whose words they are; plain wrapping without it (tests). */
+  markdown?(text: string, width: number, keep?: boolean, style?: MarkdownStyle): string[];
   /** Strike text through (an abandoned task's title); plain without it (tests). */
   strike?(text: string): string;
 }
@@ -54,7 +56,7 @@ export function strike(theme: LobbyTheme | undefined, text: string): string {
 /** `left` and `right` on one line of exactly `width` columns: the left side gives way first. */
 export function spread(left: string, right: string, width: number): string {
   if (!right) return fit(left, width);
-  const room = width - visibleWidth(right) - 1;
+  const room = width - textWidth(right) - 1;
   if (room < 4) return fit(left, width);
   return `${fit(left, room)} ${right}`;
 }
@@ -62,8 +64,8 @@ export function spread(left: string, right: string, width: number): 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 pad = width - visibleWidth(cut);
+  const cut = textWidth(text) > width ? truncateToWidth(text, width, "…") : text;
+  const pad = width - textWidth(cut);
   return pad > 0 ? `${cut}${" ".repeat(pad)}` : cut;
 }
 
@@ -83,7 +85,7 @@ export function wrap(text: string, width: number): string[] {
 
 /** Wrap with a hanging indent: the first line carries `lead`, the rest align under it. */
 export function wrapHanging(lead: string, text: string, width: number): string[] {
-  const indent = visibleWidth(lead);
+  const indent = textWidth(lead);
   const body = wrap(text, Math.max(1, width - indent));
   if (body.length === 0) return [lead];
   return body.map((line, index) => `${index === 0 ? lead : " ".repeat(indent)}${line}`);
@@ -94,7 +96,7 @@ export function rule(width: number, title = "", theme?: LobbyTheme, right = "",
   if (width <= 0) return "";
   const head = title ? `── ${title} ` : "";
   const tail = right ? ` ${right} ──` : "";
-  const fill = width - visibleWidth(head) - visibleWidth(tail);
+  const fill = width - textWidth(head) - textWidth(tail);
   if (fill < 1) return fit(paint(theme, color, head.trimEnd() || "─".repeat(width)), width);
   const titled = title ? `${paint(theme, color, "── ")}${bold(theme, paint(theme, "accent", title))}${paint(theme, color, " ")}` : "";
   const ending = right ? `${paint(theme, color, " ")}${paint(theme, "muted", right)}${paint(theme, color, " ──")}` : "";
@@ -183,8 +185,8 @@ export function spinner(tick: number): string {
 }
 
 /** 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);
+export function markdownLines(text: string, width: number, theme?: LobbyTheme, keep = true, style: MarkdownStyle = "reply"): string[] {
+  if (theme?.markdown) return theme.markdown(text, width, keep, style);
   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);
@@ -192,9 +194,9 @@ export function markdownLines(text: string, width: number, theme?: LobbyTheme):
 }
 
 /** 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);
+export function markdownHanging(lead: string, text: string, width: number, theme?: LobbyTheme, style: MarkdownStyle = "reply"): string[] {
+  const indent = textWidth(lead);
+  const body = markdownLines(text, Math.max(1, width - indent), theme, true, style);
   if (body.length === 0) return [lead];
   return body.map((line, index) => (index === 0 ? `${lead}${line}` : line ? `${" ".repeat(indent)}${line}` : ""));
 }
@@ -210,6 +212,18 @@ export interface BoxOptions {
   scroll?: { total: number; start: number };
 }
 
+/** An entry of a pane (a message, a thought, an activity line) and how many lines run from its first line to the pane's end. */
+export interface PaneMark {
+  entry: object;
+  below: number;
+}
+
+/** A pane that measures what arrives below: its newest entry now, and the lines that arrived below the one marked the frame before. */
+export interface PaneFollow {
+  mark?: PaneMark;
+  grew: 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;
@@ -219,14 +233,20 @@ export interface PaneBox {
   /** Lines of content, and rows showing them at once. */
   total: number;
   rows: number;
+  /**
+   * Set by panes whose total is estimated: lines that arrived below since the
+   * frame before, measured from an entry, not from the total (which moves as
+   * scrolling draws more or fewer of the entries it estimates).
+   */
+  follow?: PaneFollow;
 }
 
 /** 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) });
+export function notePane(panes: PaneLayout | undefined, name: string, top: number, left: number, width: number, height: number, total: number, follow?: PaneFollow): void {
+  panes?.set(name, { top, left, width, height, total, rows: Math.max(0, height - 2), ...(follow ? { follow } : {}) });
 }
 
 /** First line of a top-anchored pane scrolled `offset` lines down, stopping when its last line shows. */
@@ -261,11 +281,11 @@ export function box(width: number, height: number, content: readonly string[], o
   const inner = width - 4;
   const title = options.title ? ` ${options.title} ` : "";
   const right = options.right ? ` ${options.right} ` : "";
-  let room = width - 2 - visibleWidth(title) - visibleWidth(right);
+  let room = width - 2 - textWidth(title) - textWidth(right);
   const shownRight = room >= 1 ? right : "";
-  room = width - 2 - visibleWidth(title) - visibleWidth(shownRight);
+  room = width - 2 - textWidth(title) - textWidth(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 fillWidth = Math.max(0, width - 2 - textWidth(titled) - textWidth(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;

package/src/lobby/markdown.ts

@@ -1,15 +1,41 @@
 /**
  * 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.
+ * heading hashes dropped for a cleaner read. Renders are cached per width and
+ * text, since the lobby repaints many times a second.
  */
 import { getMarkdownTheme } from "@earendil-works/pi-coding-agent";
-import { Markdown, stripTerminalSequences, type MarkdownTheme } from "@earendil-works/pi-tui";
+import { Markdown, stripTerminalSequences, type DefaultTextStyle, type MarkdownOptions, type MarkdownTheme } from "@earendil-works/pi-tui";
 
-export type MarkdownRenderer = (text: string, width: number) => string[];
+/**
+ * Whose words a piece of Markdown is, which sets how its plain text reads, as
+ * pi draws the same things: an agent's reply in the theme's text colour, your
+ * own words in yours (list markers and backslash escapes kept as typed), a
+ * thought dimmed and in italics.
+ */
+export type MarkdownStyle = "reply" | "you" | "thought";
+
+/** The plain-text look of each style but a reply; the lobby takes them from the session's theme. */
+export type MarkdownStyles = Partial<Record<Exclude<MarkdownStyle, "reply">, DefaultTextStyle>>;
 
-const CACHE_LIMIT = 96;
+/** Markdown rendered to lines at a width; `keep: false` for text seen once (a reply still streaming), so it does not crowd the cache. */
+export type MarkdownRenderer = (text: string, width: number, keep?: boolean, style?: MarkdownStyle) => string[];
+
+/** How pi renders what you write: your ordered-list markers and backslash escapes stay as you typed them. */
+const YOUR_WORDS: MarkdownOptions = { preserveOrderedListMarkers: true, preserveBackslashEscapes: true };
+
+/**
+ * Line breaks a model wrote out as `\n` (text escaped twice on its way here,
+ * so a whole plan arrives as one line): made real when the text has no real
+ * line break at all, outside inline code, where `\n` is usually meant.
+ */
+export function unescapeBreaks(text: string): string {
+  if (text.includes("\n") || !text.includes("\\n")) return text;
+  return text
+    .split(/(`[^`\n]*`)/)
+    .map((part, index) => (index % 2 === 1 ? part : part.replace(/(?:\\r)?\\n/g, "\n")))
+    .join("");
+}
 
 /** 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)*)/;
@@ -21,28 +47,75 @@ export function tidyHeading(line: string, bold: (text: string) => string): strin
   return bold(body.trimEnd());
 }
 
+/** Rendered Markdown kept per renderer: the most recently used survive. */
+export const CACHE_LIMIT = 512;
+
 /**
- * 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.
+ * A renderer for one Markdown theme. Renders are kept per width and text, the
+ * least recently used dropped first. pi's `getMarkdownTheme()` builds a new
+ * theme object on every call, so the theme is taken once, here: a theme
+ * switch makes a new renderer (the lobby keeps one per pi theme).
  */
-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}`;
+export function createMarkdownRenderer(theme: MarkdownTheme = getMarkdownTheme(), styles: MarkdownStyles = {}): MarkdownRenderer {
+  const cache = new Map<string, string[]>();
+  return (text, width, keep = true, style = "reply") => {
+    const key = `${style}\0${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));
+    if (hit) {
+      // Most recently used last, so the oldest is the one dropped.
+      cache.delete(key);
+      cache.set(key, hit);
+      return hit;
+    }
+    const look = style === "reply" ? undefined : styles[style];
+    const lines = new Markdown(unescapeBreaks(text), 0, 0, theme, look, style === "you" ? YOUR_WORDS : undefined)
+      .render(Math.max(1, width))
+      .map((line) => tidyHeading(line.trimEnd(), theme.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();
+    if (!keep) return lines;
     cache.set(key, lines);
     if (cache.size > CACHE_LIMIT) cache.delete(cache.keys().next().value!);
     return lines;
   };
 }
+
+/** A fenced code block's opening or closing line. */
+const FENCE = /^ {0,3}(`{3,}|~{3,})/;
+/** A list item's first line: after a blank line it continues the list above, so blocks never split there. */
+const LIST_ITEM = /^(?:[-*+]|\d{1,9}[.)])(?:\s|$)/;
+
+/**
+ * Markdown split into blocks that render, one by one, into the same lines as
+ * the whole (each block's lines, a blank line between blocks, blocks that
+ * render to nothing left out). A split falls on a blank line outside code
+ * fences that is followed by an unindented line that does not start a list
+ * item — the only places where one block can never run into the next. A
+ * streaming reply can then keep its finished blocks rendered and render only
+ * the one still being written.
+ */
+export function markdownBlocks(text: string): string[] {
+  const lines = text.split("\n");
+  const blocks: string[] = [];
+  let fence: string | undefined;
+  let start = 0;
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index]!;
+    const marker = FENCE.exec(line)?.[1];
+    if (marker) {
+      if (!fence) fence = marker;
+      else if (marker[0] === fence[0] && marker.length >= fence.length) fence = undefined;
+      continue;
+    }
+    if (fence || line.trim() || index === 0) continue;
+    const next = lines[index + 1];
+    if (next === undefined || !/^\S/.test(next) || LIST_ITEM.test(next)) continue;
+    const block = lines.slice(start, index).join("\n");
+    if (block.trim()) blocks.push(block);
+    start = index + 1;
+  }
+  const last = lines.slice(start).join("\n");
+  if (last.trim()) blocks.push(last);
+  return blocks;
+}

package/src/lobby/planner.ts

@@ -37,7 +37,7 @@ import { fellShort, profileLabel, type EffortRouter, type EffortScore } from "..
 
 /** Seats and the oracle read the repository to ask informed questions; they never edit. */
 export const PLANNER_TOOLS: readonly string[] = ["read", "grep", "find", "ls"];
-/** RESEARCH also gets the web tools (from pi-web-access; pi ignores them when it is not installed). */
+/** RESEARCH also gets bot-lobby's web tools (src/web/tools.ts). */
 export const RESEARCH_PANEL_TOOLS: readonly string[] = [...PLANNER_TOOLS, "web_search", "fetch_content", "source_check", "get_search_content"];
 
 /** The chair of the panel, as the Plan tab, the feed and the metrics name it. */

package/src/lobby/quickfix.ts

@@ -9,6 +9,7 @@ import { loadPrompt } from "../prompts/loader.ts";
 import { runPiAgent, spawnPiProcess, type PiStreamEvent, type ProcessRunner } from "../execution/pi-runner.ts";
 import { describeToolCall } from "../pi/activity.ts";
 import { appendMetrics, type MetricRecord } from "../state/metrics.ts";
+import { appendChange, EditLog } from "../state/changes.ts";
 import type { LobbyFeed } from "./feed.ts";
 import type { FileHinter } from "../classifier/files.ts";
 import type { Classifier } from "../classifier/classifier.ts";
@@ -51,6 +52,8 @@ export interface QuickFixJob {
   /** The classifier routed it down (`trivial 0.88: p/big · low → p/cheap · low`); cleared when it re-ran on the configured profile. */
   route?: string;
   routedFrom?: string;
+  /** Files it changed with `edit`/`write`, as shown (relative to the project); the change ledger lets a running task's QA gate tell them from its own. */
+  files?: string[];
 }
 
 export interface QuickFixProfile {
@@ -103,6 +106,7 @@ export class QuickFixQueue {
   jobs: QuickFixJob[] = [];
   private readonly deps: QuickFixDeps;
   private readonly controllers = new Map<string, AbortController>();
+  private readonly edits = new Map<string, EditLog>();
   private counter = 0;
 
   constructor(deps: QuickFixDeps) {
@@ -188,6 +192,8 @@ export class QuickFixQueue {
     const now = Date.now();
     if (event.type === "tool_execution_start") {
       job.tools += 1;
+      const edits = this.edits.get(job.id);
+      if (edits?.note(event.toolName, event.args)) job.files = edits.shown();
       this.addStep(job, describeToolCall(event.toolName, event.args), now);
     } else if (event.type === "turn_start") job.turns += 1;
     else if (event.type === "thought") this.deps.feed?.thought(QUICK_FIX_SOURCE, event.text, now);
@@ -211,6 +217,7 @@ export class QuickFixQueue {
       return this.hold(job, held);
     }
     this.deps.feed?.log(QUICK_FIX_SOURCE, `started: ${jobTitle(job)}`, "info", job.startedAt);
+    this.edits.set(job.id, new EditLog(this.deps.cwd));
     try {
       const [likely, route] = await Promise.all([this.likely(job.prompt, controller.signal), this.route(job.prompt, profile, controller.signal)]);
       const attempt = (model: string | undefined, thinking: string) => runPiAgent(
@@ -309,6 +316,20 @@ export class QuickFixQueue {
   private finish(job: QuickFixJob): void {
     job.finishedAt = Date.now();
     for (const step of job.steps) step.pending = false;
+    const edited = this.edits.get(job.id)?.list() ?? [];
+    this.edits.delete(job.id);
+    // Whatever it edited, even when it failed, is on record for a task's QA gate as the user's own request.
+    if (edited.length > 0) {
+      appendChange(this.deps.root, this.deps.configDir, {
+        source: "quickfix",
+        id: job.id,
+        what: jobTitle(job),
+        files: edited,
+        startedAt: new Date(job.startedAt ?? job.createdAt).toISOString(),
+        finishedAt: new Date(job.finishedAt).toISOString(),
+        status: job.status,
+      });
+    }
     this.deps.feed?.end(job.id, job.status !== "success");
     const ok = job.status === "success";
     const outcome = ok ? "done" : `${job.status}${job.error ? ` — ${job.error.split("\n")[0]}` : ""}`;