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

package/README.md

@@ -74,6 +74,13 @@ agreed in the Plan tab skips approval too.
 **Safety nets:** every agent has a time limit (asked to wrap up at 75%), a
 stall watchdog and one retry; `Esc` aborts every running agent.
 
+**A fresh context per task.** Every agent runs in its own Pi process with its
+own context. The oracle, which is your session, starts each task clean: its
+model sees only the conversation since the task started, and once a task ends
+your next request starts fresh (the lobby shows *context cleared*, and the
+oracle is told where the finished task's record is). The session file keeps
+everything. `workflow.freshContext: false` in the config turns this off.
+
 ## The lobby
 
 A full-screen view with a prompt at the bottom that talks to whatever tab is
@@ -96,6 +103,9 @@ Rebind any key under `lobby.keys` in the config.
 Pi session. The Lobby tab can show any session, and your prompt steers it;
 `● waiting` in the tab bar means one has a question for you.
 
+The conversation keeps its newest 100 messages in memory; scroll to the top
+to load the rest.
+
 ## Planning
 
 Describe an idea on the Plan tab. Each round, the **seats** — DEV, DESIGN, QA

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a-t-h-i/bot-lobby",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "description": "Structured multi-agent software engineering orchestrator for Pi",
   "type": "module",
   "license": "Apache-2.0",

package/src/index.ts

@@ -10,10 +10,13 @@ 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);

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;
+}

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";
@@ -28,7 +28,7 @@ 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";
@@ -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 {
@@ -478,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) {
@@ -490,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);
@@ -515,7 +548,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 +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(),
   };
@@ -742,7 +777,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));