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

package/src/execution/agent-runner.ts

@@ -55,6 +55,9 @@ export interface AgentRequest {
   onStart?: (handle: AgentHandle) => void;
   /** Called once per attempt after it ends, before any retry. */
   onAttemptEnd?: (run: AgentRun) => void;
+  /** The classifier routed this run down from this configured profile (receipts and metrics show it). */
+  routedFrom?: string;
+  route?: string;
 }
 
 /** The watchdog fields of an AgentRequest, taken from the workflow config. */
@@ -115,6 +118,8 @@ function baseRun(request: AgentRequest, runId: string, startedAt: string, attemp
     attempts,
     startedAt,
     ...(request.thinking ? { thinking: request.thinking } : {}),
+    ...(request.routedFrom ? { routedFrom: request.routedFrom } : {}),
+    ...(request.route ? { route: request.route } : {}),
     ...(attempts > 1 ? { note: `retry ${attempts - 1} of ${(request.retries ?? 0)}`, noteKind: "warning" as const } : {}),
   };
 }

package/src/index.ts

@@ -8,8 +8,15 @@ import { isSubagentProcess } from "./pi/quiet.ts";
 import { registerDeskClient } from "./desk/client-extension.ts";
 import { registerLobbyEvents } from "./lobby/runtime.ts";
 import { registerOwner } from "./pi/owner.ts";
+import { registerClassifier } from "./classifier/instance.ts";
+import { registerClassifierTools } from "./classifier/tools.ts";
+import { registerFreshContext } from "./pi/fresh-context.ts";
 
 export default function (pi: ExtensionAPI): void {
+  // First, so every session_start handler below finds the classifier bound to this session's keys.
+  registerClassifier(pi, CONFIG_DIR_NAME);
+  // Before the lifecycle, so a task that ended while the oracle was idle is closed before it builds the next turn's prompt.
+  registerFreshContext(pi, CONFIG_DIR_NAME);
   registerLifecycle(pi, CONFIG_DIR_NAME);
   // After the lifecycle, so the lobby opens over a task the widget state already knows.
   registerLobbyEvents(pi, CONFIG_DIR_NAME);
@@ -19,4 +26,6 @@ export default function (pi: ExtensionAPI): void {
   registerOrchestrateTool(pi, CONFIG_DIR_NAME);
   // Parallel workers share files through the master's file desk.
   if (isSubagentProcess()) registerDeskClient(pi);
+  // Subagents look files up with the classifier (the engine allows the tool only while file hints are on).
+  if (isSubagentProcess()) registerClassifierTools(pi);
 }

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,8 @@
  * 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";
 
 /** Colours the lobby uses; a subset of pi's theme so tests can pass a plain stub. */
 export type LobbyColor =
@@ -29,7 +30,7 @@ export interface LobbyTheme {
   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[];
+  markdown?(text: string, width: number, keep?: boolean): string[];
   /** Strike text through (an abandoned task's title); plain without it (tests). */
   strike?(text: string): string;
 }
@@ -54,7 +55,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 +63,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 +84,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 +95,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 +184,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): string[] {
+  if (theme?.markdown) return theme.markdown(text, width, keep);
   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);
@@ -193,7 +194,7 @@ 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 indent = textWidth(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}` : ""));
@@ -261,11 +262,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,14 @@
 /**
  * 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";
 
-export type MarkdownRenderer = (text: string, width: number) => string[];
-
-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) => string[];
 
 /** 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 +20,72 @@ 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);
-    }
+export function createMarkdownRenderer(theme: MarkdownTheme = getMarkdownTheme()): MarkdownRenderer {
+  const cache = new Map<string, string[]>();
+  return (text, width, keep = true) => {
     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));
+    if (hit) {
+      // Most recently used last, so the oldest is the one dropped.
+      cache.delete(key);
+      cache.set(key, hit);
+      return hit;
+    }
+    const lines = new Markdown(text, 0, 0, theme).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;
+}