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

package/src/lobby/quickfix.ts

@@ -10,13 +10,18 @@ import { runPiAgent, spawnPiProcess, type PiStreamEvent, type ProcessRunner } fr
 import { describeToolCall } from "../pi/activity.ts";
 import { appendMetrics, type MetricRecord } from "../state/metrics.ts";
 import type { LobbyFeed } from "./feed.ts";
+import type { FileHinter } from "../classifier/files.ts";
+import type { Classifier } from "../classifier/classifier.ts";
+import { quickFixSize } from "../classifier/triage.ts";
+import { fellShort, profileLabel, routeLabel, type EffortRoute, type EffortRouter } from "../classifier/effort.ts";
 
 /** A quick fix edits code, so it gets the full coding tool set. */
 export const QUICK_FIX_TOOLS: readonly string[] = ["read", "bash", "edit", "write", "grep", "find", "ls"];
 
 export const QUICK_FIX_SOURCE = "QUICK FIX";
 
-export type QuickFixStatus = "queued" | "running" | "success" | "failed" | "cancelled" | "timeout";
+/** `held`: the classifier judged the request a task, not a quick fix; it waits for you (r runs it anyway, t makes it a task). */
+export type QuickFixStatus = "queued" | "running" | "success" | "failed" | "cancelled" | "timeout" | "held";
 
 export interface QuickFixStep {
   at: number;
@@ -39,6 +44,13 @@ export interface QuickFixJob {
   report?: string;
   error?: string;
   usage?: { input: number; output: number; cost: number; turns: number };
+  /** Why the job was held, or what became of it. */
+  note?: string;
+  /** Run even if the classifier judges it large (r on a held job). */
+  force?: boolean;
+  /** 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;
 }
 
 export interface QuickFixProfile {
@@ -61,6 +73,12 @@ export interface QuickFixDeps {
   /** Called after every change so the lobby can repaint. */
   onChange?: () => void;
   notify?: (message: string, level: "info" | "warning" | "error") => void;
+  /** Likely files for the prompt, and the lookup tool, while the classifier's file hints are on. */
+  hints?: FileHinter;
+  /** Holds a request it judges large (a task, not a quick fix) instead of spending a run on it. */
+  classifier?: Classifier;
+  /** Lowers thinking or the model for a request the classifier judges simple or trivial. */
+  effort?: EffortRouter;
 }
 
 export const MAX_JOBS = 30;
@@ -120,6 +138,30 @@ export class QuickFixQueue {
     return true;
   }
 
+  /** Run a held job anyway: it goes back in the queue and is not sized again. */
+  runAnyway(id: string): boolean {
+    const job = this.jobs.find((entry) => entry.id === id);
+    if (!job || job.status !== "held") return false;
+    job.status = "queued";
+    job.force = true;
+    delete job.note;
+    delete job.startedAt;
+    delete job.finishedAt;
+    this.changed();
+    this.pump();
+    return true;
+  }
+
+  /** A held job that became a task: it leaves the queue with a note. */
+  movedToTask(id: string): boolean {
+    const job = this.jobs.find((entry) => entry.id === id);
+    if (!job || job.status !== "held") return false;
+    job.status = "cancelled";
+    job.note = "started as a task in a new session";
+    this.changed();
+    return true;
+  }
+
   /** Abort everything (session shutdown). */
   cancelAll(): void {
     for (const job of this.jobs) if (job.status === "queued") job.status = "cancelled";
@@ -162,17 +204,23 @@ export class QuickFixQueue {
     job.startedAt = Date.now();
     job.thinking = profile.thinking;
     if (profile.model) job.model = profile.model;
-    this.deps.feed?.log(QUICK_FIX_SOURCE, `started: ${jobTitle(job)}`, "info", job.startedAt);
     this.changed();
+    const held = job.force ? undefined : await this.tooLarge(job, controller.signal);
+    if (held) {
+      this.controllers.delete(job.id);
+      return this.hold(job, held);
+    }
+    this.deps.feed?.log(QUICK_FIX_SOURCE, `started: ${jobTitle(job)}`, "info", job.startedAt);
     try {
-      const result = await runPiAgent(
+      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(
         {
           cwd: this.deps.cwd,
-          task: job.prompt,
+          task: likely ? `${job.prompt}\n\n${likely}` : job.prompt,
           systemPrompt: quickFixPrompt(profile.instructions),
-          tools: QUICK_FIX_TOOLS,
-          model: profile.model,
-          thinking: profile.thinking,
+          tools: [...QUICK_FIX_TOOLS, ...(this.deps.hints?.tools() ?? [])],
+          model,
+          thinking,
           timeoutMs: profile.timeoutMs,
           signal: controller.signal,
           stallTimeoutMs: this.deps.stallTimeoutMs,
@@ -181,6 +229,27 @@ export class QuickFixQueue {
         },
         this.deps.runProcess ?? spawnPiProcess,
       );
+      let result;
+      if (route) {
+        job.route = routeLabel(route);
+        job.routedFrom = profileLabel(route.from);
+        job.thinking = route.thinking;
+        if (route.model) job.model = route.model;
+        this.changed();
+        result = await attempt(route.model, route.thinking);
+        if (fellShort(result) && !controller.signal.aborted) {
+          // The routed attempt counts in the metrics on its own; the job re-runs on the configured profile.
+          appendMetrics(this.deps.root, this.deps.configDir, [{ ...quickFixMetric({ ...job, status: result.status, finishedAt: Date.now(), usage: result.usage, ...(result.model ? { model: result.model } : {}) }), id: `${job.id}-routed-${job.startedAt}` }]);
+          this.addStep(job, "the routed attempt fell short; running again on the configured model and thinking", Date.now());
+          delete job.route;
+          delete job.routedFrom;
+          job.thinking = profile.thinking;
+          if (profile.model) job.model = profile.model;
+          result = await attempt(profile.model, profile.thinking);
+        }
+      } else {
+        result = await attempt(profile.model, profile.thinking);
+      }
       job.status = result.status;
       job.report = result.output.trim() || undefined;
       job.error = result.error;
@@ -195,6 +264,48 @@ export class QuickFixQueue {
     }
   }
 
+  /** Where the classifier routes this request, or undefined. */
+  private async route(prompt: string, profile: QuickFixProfile, signal: AbortSignal): Promise<EffortRoute | undefined> {
+    try {
+      return await this.deps.effort?.route(prompt, { ...(profile.model ? { model: profile.model } : {}), thinking: profile.thinking }, { signal });
+    } catch {
+      return undefined;
+    }
+  }
+
+  /** Why a request is too large for a quick fix, when the classifier is sure; undefined runs it. */
+  private async tooLarge(job: QuickFixJob, signal: AbortSignal): Promise<string | undefined> {
+    const jev = this.deps.classifier;
+    if (!jev?.enabled("triage")) return undefined;
+    try {
+      const sized = await quickFixSize(jev, job.prompt, signal);
+      if (!sized || sized.size !== "large" || sized.confidence < jev.config.thresholds.quickFixLargeAt) return undefined;
+      return `looks like a task (large, ${sized.confidence.toFixed(2)})`;
+    } catch {
+      return undefined;
+    }
+  }
+
+  /** Hold a job instead of running it; nothing ran, so nothing lands in the metrics. */
+  private hold(job: QuickFixJob, note: string): void {
+    job.status = "held";
+    job.note = note;
+    job.finishedAt = Date.now();
+    this.deps.feed?.log(QUICK_FIX_SOURCE, `held: ${jobTitle(job)} — ${note}; r runs it anyway, t makes it a task`, "warning", job.finishedAt);
+    this.deps.notify?.(`bot-lobby quick fix held: ${jobTitle(job)} ${note}`, "warning");
+    this.changed();
+    this.pump();
+  }
+
+  /** The Likely files block for a prompt, or "" (no hints, nothing stands out, out of time). */
+  private async likely(prompt: string, signal: AbortSignal): Promise<string> {
+    try {
+      return (await this.deps.hints?.block(prompt, signal)) ?? "";
+    } catch {
+      return "";
+    }
+  }
+
   private finish(job: QuickFixJob): void {
     job.finishedAt = Date.now();
     for (const step of job.steps) step.pending = false;
@@ -217,11 +328,12 @@ export function quickFixMetric(job: QuickFixJob): MetricRecord {
     agent: QUICK_FIX_SOURCE,
     ...(job.model ? { model: job.model } : {}),
     ...(job.thinking ? { thinking: job.thinking } : {}),
-    status: job.status === "queued" || job.status === "running" ? "failed" : job.status,
+    status: job.status === "queued" || job.status === "running" ? "failed" : job.status === "held" ? "cancelled" : job.status,
     startedAt: new Date(started).toISOString(),
     durationMs: Math.max(0, (job.finishedAt ?? started) - started),
     turns: job.usage?.turns || job.turns || undefined,
     tools: job.tools,
     ...(job.usage ? { input: job.usage.input, output: job.usage.output, cost: job.usage.cost } : {}),
+    ...(job.routedFrom ? { routedFrom: job.routedFrom } : {}),
   };
 }

package/src/lobby/runtime.ts

@@ -7,10 +7,10 @@
  * records each Master turn in the metrics log.
  */
 import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
-import { getSelectListTheme, SessionManager } from "@earendil-works/pi-coding-agent";
+import { getMarkdownTheme, getSelectListTheme, SessionManager } from "@earendil-works/pi-coding-agent";
 import { Key, type OverlayHandle, type TUI } from "@earendil-works/pi-tui";
 import { TERMINAL_STATES, type Task } from "../schemas/task.ts";
-import { listTasks, loadTask } from "../state/persistence.ts";
+import { loadTask, peekTasks } from "../state/persistence.ts";
 import { detectProjectRoot, loadConfig, saveConfig } from "../state/project.ts";
 import { addPlanComment, readPlanComments } from "../state/comments.ts";
 import { isAutoMode } from "../state/auto.ts";
@@ -18,7 +18,7 @@ import { sendToInbox, sendToSession as leaveForSession } from "../state/inbox.ts
 import { livePresence } from "../state/presence.ts";
 import { archiveTask as archiveTaskOnDisk, deleteTask as deleteTaskOnDisk, listArchivedTasks, restoreTask as restoreTaskOnDisk } from "../state/archive.ts";
 import { discardPlannedTask, listPlannedTasks, type PlannedTask } from "../state/backlog.ts";
-import { appendMetrics, readMetrics, type MetricStatus } from "../state/metrics.ts";
+import { appendMetrics, readClassifierMetrics, readMetrics, type MetricStatus } from "../state/metrics.ts";
 import { describeToolCall } from "../pi/activity.ts";
 import { applyStatus, currentZenTask, isMinimized, onMinimizeChange, onRunUpdates, persistedRuns, setMinimized, setWidgetSuppressor, ZenScene, zenSnapshot } from "../pi/ui.ts";
 import { panelLines } from "../pi/zen.ts";
@@ -28,7 +28,9 @@ import { modelRef, resolveLobbyProfile, resolvePanelProfile } from "../pi/model-
 import { modelLookup } from "../pi/tools.ts";
 import { startPlannedTask, startTask } from "../pi/start-task.ts";
 import type { LobbyAgentKind, LobbyPanel, PanelMember } from "../schemas/configuration.ts";
-import { chatFromEntries, lobbyFeed, narrateEvent, type AgentEventLike } from "./feed.ts";
+import { chatFromEntries, lobbyFeed, narrateEvent, type AgentEventLike, type ChatEntry } from "./feed.ts";
+import { classifier, effortFor, hintsFor } from "../classifier/instance.ts";
+import { checkThinking } from "../pi/model-support.ts";
 import { launchPi, SessionRegistry, type BackgroundSession, type SessionLauncher } from "./sessions.ts";
 import { SessionChats } from "./session-files.ts";
 import { answerMessage, dialogAsker, loadAskTool, questionnaires, toolAsker, type Asker } from "./ask.ts";
@@ -81,8 +83,28 @@ export function lobbyView(): LobbyView | undefined {
   return runtime?.view;
 }
 
+/** Repaints asked for by what happens in the background (a streamed token, a run update) come at most this often. */
+export const FRAME_MS = 40;
+let lastFrame = 0;
+let frameTimer: ReturnType<typeof setTimeout> | undefined;
+
+/**
+ * Repaint the lobby for something that happened in the background. A reply
+ * streams dozens of events a second; they share frames, at most one per
+ * `FRAME_MS`, instead of each asking for its own. Keys repaint at once
+ * through pi.
+ */
 function rerender(): void {
-  if (runtime?.visible) runtime.tui?.requestRender();
+  if (!runtime?.visible || frameTimer) return;
+  const wait = lastFrame + FRAME_MS - Date.now();
+  const paint = () => {
+    frameTimer = undefined;
+    lastFrame = Date.now();
+    if (runtime?.visible) runtime.tui?.requestRender();
+  };
+  if (wait <= 0) return paint();
+  frameTimer = setTimeout(paint, wait);
+  frameTimer.unref?.();
 }
 
 function sessionModel(ctx: ExtensionContext): string | undefined {
@@ -302,6 +324,16 @@ function liveSessions(state: Runtime): LiveSession[] {
   return sessions;
 }
 
+/**
+ * A session's whole conversation, oldest first: this window's from pi's
+ * branch (already in memory), another's from its session file. Loaded only
+ * while the lobby is scrolled back through it.
+ */
+function chatHistory(state: Runtime, sessionId?: string): ChatEntry[] {
+  if (sessionId) return chats.history(sessionId);
+  return chatFromEntries(state.ctx.sessionManager.getBranch(), Number.POSITIVE_INFINITY).map((line, index) => ({ id: -(index + 1), at: line.at ?? 0, role: line.role, text: line.text }));
+}
+
 /** Leave a message for a session running in another terminal. */
 function sendToSession(state: Runtime, sessionId: string, text: string): string {
   try {
@@ -415,6 +447,10 @@ function newPlanner(state: Runtime, seed?: PlannerSeed, seats?: readonly PanelMe
     profile: () => lobbyProfile(state, "planner"),
     memberProfile: (member) => seatProfile(state, member),
     panel: seats ?? config.lobby.planningPanel,
+    maxRounds: () => loadConfig().lobby.maxPlanningRounds,
+    classifier: classifier(),
+    hints: hintsFor({ cwd: state.ctx.cwd, root: state.root, configDir: state.configDir }),
+    effort: effortFor((model, thinking) => checkThinking(modelLookup(state.ctx)(model), thinking).level),
     stallTimeoutMs: workflow.stallTimeoutMs,
     toolStallTimeoutMs: workflow.toolStallTimeoutMs,
     feed: lobbyFeed,
@@ -472,10 +508,13 @@ export async function answerPanel(state: Runtime | undefined = runtime): Promise
   }
 }
 
-const renderMarkdown = createMarkdownRenderer();
 const lobbyThemes = new WeakMap<Theme, LobbyTheme>();
 
-/** pi's theme as the lobby draws with it, plus Markdown rendering; one wrapper per theme so caches stay warm. */
+/**
+ * pi's theme as the lobby draws with it, plus Markdown rendering; one wrapper
+ * (and one Markdown renderer with its cache) per theme, so caches stay warm
+ * and a theme switch starts fresh.
+ */
 function lobbyTheme(theme: Theme): LobbyTheme {
   let wrapped = lobbyThemes.get(theme);
   if (!wrapped) {
@@ -484,7 +523,7 @@ function lobbyTheme(theme: Theme): LobbyTheme {
       bold: (text) => theme.bold(text),
       italic: (text) => theme.italic(text),
       bg: (color, text) => theme.bg(color, text),
-      markdown: renderMarkdown,
+      markdown: createMarkdownRenderer(getMarkdownTheme()),
       strike: (text) => theme.strikethrough(text),
     };
     lobbyThemes.set(theme, wrapped);
@@ -509,10 +548,11 @@ function host(state: Runtime, tui: TUI): LobbyHost {
     },
     feed: lobbyFeed,
     masterBusy: () => !state.ctx.isIdle(),
-    tasks: () => listTasks(state.root, state.configDir),
+    tasks: () => peekTasks(state.root, state.configDir),
     plans: () => listPlannedTasks(state.root, state.configDir),
     comments: (taskId) => readPlanComments(state.root, state.configDir, taskId),
     metrics: () => readMetrics(state.root, state.configDir),
+    classifierMetrics: () => readClassifierMetrics(state.root, state.configDir),
     toOracle: (text) => toOracle(state, text),
     comment: (taskId, text) => addComment(state, taskId, text),
     startPlanned: (plan) => startPlanned(state, plan),
@@ -524,6 +564,7 @@ function host(state: Runtime, tui: TUI): LobbyHost {
     newPlanner: (seed, seats) => newPlanner(state, seed, seats),
     answerPanel: () => answerPanel(state),
     defaultPanel: () => loadConfig().lobby.planningPanel,
+    planningRounds: () => loadConfig().lobby.maxPlanningRounds,
     issuesEnabled: () => loadConfig().lobby.issues,
     panels: () => loadConfig().lobby.panels,
     savePanels: (panels) => savePanels(panels),
@@ -553,6 +594,8 @@ function host(state: Runtime, tui: TUI): LobbyHost {
     restoreTask: (taskId) => restoreTask(state, taskId),
     deleteTask: (taskId, where) => deleteTask(state, taskId, where),
     sessionChat: (sessionId) => chats.chat(sessionId),
+    hasOlderChat: (sessionId) => chats.hasOlder(sessionId),
+    chatHistory: (sessionId) => chatHistory(state, sessionId),
     taskScene: (task, width, height) => taskScene(state, task, width, height),
     requestRender: () => tui.requestRender(),
   };
@@ -728,10 +771,14 @@ export function initLobby(pi: ExtensionAPI, ctx: ExtensionContext, configDir: st
     notify: (message, level) => {
       if (!state.visible) ctx.ui.notify(message, level);
     },
+    hints: hintsFor({ cwd: ctx.cwd, root, configDir }),
+    classifier: classifier(),
+    effort: effortFor((model, thinking) => checkThinking(modelLookup(ctx)(model), thinking).level),
   });
   runtime = state;
   lobbyFeed.clear();
-  lobbyFeed.seedChat(chatFromEntries(ctx.sessionManager.getBranch()));
+  // Only the newest messages are kept; the feed learns whether earlier ones exist, and loads them when scrolled to.
+  lobbyFeed.seedChat(chatFromEntries(ctx.sessionManager.getBranch(), Number.POSITIVE_INFINITY));
   state.unsubscribeFeed = lobbyFeed.onChange(rerender);
   setWidgetSuppressor(() => runtime?.visible === true);
   onRunUpdates((runs) => lobbyFeed.runs(runs));

package/src/lobby/session-files.ts

@@ -2,10 +2,12 @@
  * Other sessions' conversations, read from their saved pi session files. A
  * task another terminal drives has no live feed in this window, so the lobby
  * shows what its session file holds: the current branch's user and assistant
- * messages, reread whenever the file changes.
+ * messages. Files are read as they grow — only the bytes appended since the
+ * last look — and only what the conversation needs is kept: each entry's
+ * parent, and the text of user and assistant messages (never tool output).
  */
-import { readFileSync, statSync } from "node:fs";
-import { chatFromEntries, MAX_CHAT, type ChatEntry } from "./feed.ts";
+import { closeSync, openSync, readSync, statSync } from "node:fs";
+import { chatFromEntries, chatText, CLEARED_NOTE, isClearedMark, MAX_CHAT, textOf, type ChatEntry } from "./feed.ts";
 
 interface EntryLike {
   type?: string;
@@ -51,22 +53,151 @@ export function chatFromFile(text: string, max = MAX_CHAT): ChatEntry[] {
   return chatFromEntries(currentBranch(parseEntries(text)), max).map((line, index) => ({ id: index + 1, at: line.at ?? 0, role: line.role, text: line.text }));
 }
 
+/** What a session log keeps of one entry: its parent, and its conversation lines if it is a message. */
+interface LogNode {
+  parentId?: string;
+  chat?: ChatEntry[];
+}
+
+/** Bytes read at most per look, so a huge file is caught up over a few frames rather than in one. */
+const READ_CHUNK = 4 * 1024 * 1024;
+
+let logIds = 0;
+
+/**
+ * One session file, followed as it grows. Its entries form a tree (pi
+ * branches); the conversation is the branch that ends at the newest entry.
+ * The newest messages are kept ready; the whole history is walked only when
+ * asked for.
+ */
+export class SessionLog {
+  readonly path: string;
+  private offset = 0;
+  private leaf?: string;
+  private readonly nodes = new Map<string, LogNode>();
+  private recentCache?: { max: number; entries: ChatEntry[]; older: boolean };
+
+  constructor(path: string) {
+    this.path = path;
+  }
+
+  /** Read what was appended since the last look; true when the conversation may have changed. */
+  update(): boolean {
+    let size: number;
+    try {
+      size = statSync(this.path).size;
+    } catch {
+      return false;
+    }
+    if (size < this.offset) this.reset();
+    if (size === this.offset) return false;
+    let changed = false;
+    let fd: number | undefined;
+    try {
+      fd = openSync(this.path, "r");
+      while (this.offset < size) {
+        const length = Math.min(READ_CHUNK, size - this.offset);
+        const buffer = Buffer.alloc(length);
+        const read = readSync(fd, buffer, 0, length, this.offset);
+        // Only whole lines: a line still being written (or a character cut in two) waits for the next look.
+        const end = buffer.lastIndexOf(0x0a, read - 1);
+        if (end < 0) break;
+        for (const line of buffer.toString("utf8", 0, end).split("\n")) changed = this.add(line) || changed;
+        this.offset += end + 1;
+        if (length === READ_CHUNK) break;
+      }
+    } catch {
+      // Unreadable for now; the next look tries again.
+    } finally {
+      if (fd !== undefined) closeSync(fd);
+    }
+    if (changed) this.recentCache = undefined;
+    return changed;
+  }
+
+  private reset(): void {
+    this.offset = 0;
+    this.leaf = undefined;
+    this.nodes.clear();
+    this.recentCache = undefined;
+  }
+
+  private add(line: string): boolean {
+    if (!line.trim()) return false;
+    let entry: { type?: string; id?: unknown; parentId?: unknown; timestamp?: unknown; message?: { role?: string; content?: unknown } };
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      return false;
+    }
+    if (typeof entry?.id !== "string") return false;
+    const node: LogNode = typeof entry.parentId === "string" ? { parentId: entry.parentId } : {};
+    const role = entry.message?.role;
+    const parsed = typeof entry.timestamp === "string" ? Date.parse(entry.timestamp) : Number.NaN;
+    const at = Number.isFinite(parsed) ? parsed : 0;
+    if (entry.type === "message" && (role === "user" || role === "assistant")) {
+      const chat = chatText(role, textOf(entry.message?.content)).map((part) => ({ id: ++logIds, at, role: part.role, text: part.text }));
+      if (chat.length > 0) node.chat = chat;
+    } else if (isClearedMark(entry)) {
+      node.chat = [{ id: ++logIds, at, role: "note", text: CLEARED_NOTE }];
+    }
+    this.nodes.set(entry.id, node);
+    this.leaf = entry.id;
+    return true;
+  }
+
+  /** The conversation's messages from the newest back, visiting at most `max`; whether any are left before them. */
+  private walk(max: number): { entries: ChatEntry[]; older: boolean } {
+    const parts: ChatEntry[][] = [];
+    let count = 0;
+    let older = false;
+    const seen = new Set<string>();
+    for (let id = this.leaf; id && !seen.has(id); id = this.nodes.get(id)?.parentId) {
+      seen.add(id);
+      const chat = this.nodes.get(id)?.chat;
+      if (!chat) continue;
+      if (count >= max) {
+        older = true;
+        break;
+      }
+      parts.push(chat);
+      count += chat.length;
+    }
+    const entries = parts.reverse().flat();
+    return { entries: entries.length > max ? entries.slice(-max) : entries, older: older || entries.length > max };
+  }
+
+  /** The newest `max` messages (kept until the file changes), and whether earlier ones exist. */
+  recent(max = MAX_CHAT): { entries: ChatEntry[]; older: boolean } {
+    if (this.recentCache?.max !== max) this.recentCache = { max, ...this.walk(max) };
+    return this.recentCache;
+  }
+
+  /** Every message of the conversation, oldest first (for scrolling back through it). */
+  history(): ChatEntry[] {
+    return this.walk(Number.POSITIVE_INFINITY).entries;
+  }
+}
+
 /** How the cache finds session files: pi's session list, id → path. */
 export type SessionLister = () => Promise<ReadonlyArray<{ id: string; path: string }>>;
 
 /** How often the id → path map is refreshed while someone looks. */
 export const LIST_REFRESH_MS = 5000;
 
+/** Session files followed at once; the least recently looked at is let go past this. */
+export const MAX_LOGS = 8;
+
 /**
- * Chats of sessions by id, cached per file and reread only when its size or
- * mtime changes. Finding a file is async (pi lists sessions from disk), so the
+ * Chats of sessions by id, each followed through a `SessionLog` (only new
+ * bytes read). Finding a file is async (pi lists sessions from disk), so the
  * first look returns nothing and `onChange` fires once new files are known.
  */
 export class SessionChats {
   private paths = new Map<string, string>();
   private listing?: Promise<void>;
   private listedAt = Number.NEGATIVE_INFINITY;
-  private readonly chats = new Map<string, { stamp: string; chat: ChatEntry[] }>();
+  private readonly logs = new Map<string, SessionLog>();
 
   private readonly list: SessionLister;
   private readonly onChange: () => void;
@@ -95,30 +226,36 @@ export class SessionChats {
     this.paths.set(sessionId, path);
   }
 
-  chat(sessionId: string): ChatEntry[] {
+  /** The session's log, following its file (the least recently used let go past `MAX_LOGS`). */
+  private log(sessionId: string): SessionLog | undefined {
     const path = this.paths.get(sessionId);
     if (!path) {
       // A file's path never changes, so pi's list is only read (at most every few seconds) for sessions not found yet.
       if (this.now() - this.listedAt >= LIST_REFRESH_MS) this.refresh();
-      return [];
-    }
-    let stamp: string;
-    try {
-      const stat = statSync(path);
-      stamp = `${stat.size}:${stat.mtimeMs}`;
-    } catch {
-      return this.chats.get(sessionId)?.chat ?? [];
-    }
-    const cached = this.chats.get(sessionId);
-    if (cached?.stamp === stamp) return cached.chat;
-    let chat: ChatEntry[];
-    try {
-      chat = chatFromFile(readFileSync(path, "utf8"));
-    } catch {
-      return cached?.chat ?? [];
+      return undefined;
     }
-    this.chats.set(sessionId, { stamp, chat });
-    return chat;
+    let log = this.logs.get(sessionId);
+    if (!log || log.path !== path) log = new SessionLog(path);
+    this.logs.delete(sessionId);
+    this.logs.set(sessionId, log);
+    if (this.logs.size > MAX_LOGS) this.logs.delete(this.logs.keys().next().value!);
+    log.update();
+    return log;
+  }
+
+  /** The newest messages of a session's conversation (the same objects until its file grows). */
+  chat(sessionId: string): ChatEntry[] {
+    return this.log(sessionId)?.recent().entries ?? [];
+  }
+
+  /** Whether the session has messages earlier than `chat` returns. */
+  hasOlder(sessionId: string): boolean {
+    return this.log(sessionId)?.recent().older ?? false;
+  }
+
+  /** The session's whole conversation, oldest first. */
+  history(sessionId: string): ChatEntry[] {
+    return this.log(sessionId)?.history() ?? [];
   }
 
   private refresh(): void {

package/src/lobby/sessions.ts

@@ -190,14 +190,14 @@ export class BackgroundSession {
 
   /** Split stdout into JSON lines (LF only, as pi's RPC framing requires) and handle each. */
   private receive(chunk: string): void {
-    this.buffer += chunk;
-    let newline = this.buffer.indexOf("\n");
-    while (newline >= 0) {
-      const line = this.buffer.slice(0, newline).replace(/\r$/, "");
-      this.buffer = this.buffer.slice(newline + 1);
+    const text = this.buffer + chunk;
+    let start = 0;
+    for (let newline = text.indexOf("\n"); newline >= 0; newline = text.indexOf("\n", start)) {
+      const line = text.slice(start, newline).replace(/\r$/, "");
+      start = newline + 1;
       if (line.trim()) this.handle(line);
-      newline = this.buffer.indexOf("\n");
     }
+    this.buffer = text.slice(start);
   }
 
   private handle(line: string): void {
@@ -280,7 +280,10 @@ export const launchPi: SessionLauncher = (args, cwd) => {
   return proc as unknown as SessionProcess;
 };
 
-/** Every background session this window started, oldest first. */
+/** Ended background sessions kept in the list (with their feeds); older ones are let go. */
+export const MAX_ENDED = 6;
+
+/** Every background session this window started, oldest first (ended ones beyond the newest few let go). */
 export class SessionRegistry {
   readonly sessions: BackgroundSession[] = [];
   private readonly launcher: SessionLauncher;
@@ -295,10 +298,21 @@ export class SessionRegistry {
     const proc = this.launcher(sessionArgs(start.name, model), cwd);
     const session = new BackgroundSession(proc, start, this.onChange);
     this.sessions.push(session);
+    this.prune();
     this.onChange();
     return session;
   }
 
+  /** Let go of all but the newest `MAX_ENDED` sessions that have ended (their conversations stay in their session files). */
+  private prune(): void {
+    let ended = 0;
+    for (let index = this.sessions.length - 1; index >= 0; index -= 1) {
+      if (this.sessions[index]!.alive) continue;
+      ended += 1;
+      if (ended > MAX_ENDED) this.sessions.splice(index, 1);
+    }
+  }
+
   get(key: string): BackgroundSession | undefined {
     return this.sessions.find((session) => session.key === key);
   }