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

package/src/lobby/runtime.ts

@@ -6,11 +6,11 @@
  * turn into the feed, passes plan comments to the Master that owns a task and
  * records each Master turn in the metrics log.
  */
-import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { 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";
@@ -28,20 +28,20 @@ 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";
+import { answerMessage, askUser, questionnaires, type Asker } from "./ask.ts";
 import { QuickFixQueue } from "./quickfix.ts";
 import { PlanningSession, type PlannerSeed } from "./planner.ts";
 import { execCommand, IssuesState } from "./issues.ts";
 import { LobbyView, type LiveSession, type LobbyHost, type SwitchTarget, type TabId } from "./view.ts";
-import type { LobbyTheme } from "./layout.ts";
-import { createMarkdownRenderer } from "./markdown.ts";
+import { lobbyTheme } from "./theme.ts";
 import { deliverComments, onOwnerEvent, setAuto } from "../pi/owner.ts";
 import { openEntrySettings, openSettings } from "../pi/settings-ui.ts";
+import { budgetClock } from "../state/budget.ts";
 
 export const ANCHOR_KEY = "bot-lobby-anchor";
 export { deliverComments };
@@ -62,8 +62,8 @@ interface Runtime {
   planner?: PlanningSession;
   issues: IssuesState;
   unsubscribeFeed?: () => void;
-  /** The ask-user-question tool (or pi's dialogs), loaded once on first use. */
-  asker?: Promise<Asker>;
+  /** Puts the panel's questions to the user: the questionnaire unless a test sets another. */
+  asker?: Asker;
   /** A questionnaire is on screen. */
   asking: boolean;
   /** The lobby turned the terminal's mouse reporting on (pi's regular screen only). */
@@ -83,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 {
@@ -304,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 {
@@ -395,7 +425,9 @@ function deleteTask(state: Runtime, taskId: string, where: "list" | "archive"):
 
 /** A task's status box without animations, for a session other than this window's. */
 function taskScene(state: Runtime, task: Task, width: number, height: number): string[] {
-  return panelLines(task, persistedRuns(task), Date.now(), false, { width, rows: Math.floor(height / 0.75), still: true, theme: state.ctx.ui.theme });
+  const now = Date.now();
+  const time = budgetClock(state.root, state.configDir, task.id, now);
+  return panelLines(task, persistedRuns(task), now, false, { width, rows: Math.floor(height / 0.75), still: true, theme: state.ctx.ui.theme, ...(time ? { time } : {}) });
 }
 
 function seatProfile(state: Runtime, member: PanelMember) {
@@ -433,10 +465,9 @@ function newPlanner(state: Runtime, seed?: PlannerSeed, seats?: readonly PanelMe
   return state.planner;
 }
 
-/** The library's questionnaire when it loads, pi's own dialogs otherwise. */
-function panelAsker(state: Runtime): Promise<Asker> {
-  state.asker ??= loadAskTool(state.pi).then((tool) => (tool ? toolAsker(tool) : dialogAsker()));
-  return state.asker;
+/** The questionnaire (pi's own dialogs where it cannot be drawn); tests swap it. */
+function panelAsker(state: Runtime): Asker {
+  return state.asker ?? askUser;
 }
 
 /**
@@ -453,7 +484,7 @@ export async function answerPanel(state: Runtime | undefined = runtime): Promise
   if (state.asking) return "the questions are already open";
   state.asking = true;
   try {
-    const asker = await panelAsker(state);
+    const asker = panelAsker(state);
     const chunks = questionnaires(session.questions);
     for (let index = session.answered.length; index < chunks.length; index++) {
       const result = await asker(chunks[index]!, state.ctx);
@@ -478,26 +509,6 @@ 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. */
-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),
-      markdown: renderMarkdown,
-      strike: (text) => theme.strikethrough(text),
-    };
-    lobbyThemes.set(theme, wrapped);
-  }
-  return wrapped;
-}
-
 function host(state: Runtime, tui: TUI): LobbyHost {
   return {
     rows: () => tui.terminal.rows,
@@ -515,7 +526,7 @@ 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),
@@ -561,6 +572,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(),
   };
@@ -742,7 +755,8 @@ export function initLobby(pi: ExtensionAPI, ctx: ExtensionContext, configDir: st
   });
   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);
   }