pi-jar 0.1.0 → 0.1.2

package/extensions/index.ts

@@ -37,6 +37,7 @@ import { ChangeTracker } from "../src/changes.ts";
 import { registerDelegate } from "../src/delegate.ts";
 import { collectPrompts, openPromptSearch } from "../src/prompt-search.ts";
 import { ago, recentSessions, type RecentSession } from "../src/session-gallery.ts";
+import { clearSessionBranchCache, sessionBranch } from "../src/session-branch.ts";
 import { registerChangeReview } from "../src/diff-view.ts";
 import { openShellsView, registerShells, SHELL_MESSAGE, shellEventMessage, ShellManager, type ShellEvent } from "../src/shells.ts";
 import { hopefulWelcomeMessage, welcomeHit, welcomeLines, type WelcomeAction } from "../src/welcome.ts";
@@ -48,6 +49,7 @@ const VERSION = (() => {
 })();
 /** Ignore the click Pi may synthesize right after a press we already acted on. */
 const WELCOME_CLICK_DEDUPE_MS = 400;
+const LARGE_SESSION_ENTRIES = 800;
 export default function piJar(pi: ExtensionAPI): void {
   installCompactBuiltinTools(pi);
   let demo = false;
@@ -74,9 +76,7 @@ export default function piJar(pi: ExtensionAPI): void {
   let footerSettings = visualSettings.footer;
   let welcomeStatuses = (): ReadonlyMap<string, string> => new Map();
   const working = new WorkingState();
-  let workingClock: ReturnType<typeof setInterval> | undefined;
   let workingIndicatorKey = "";
-  const stopWorkingClock = () => { if (workingClock) clearInterval(workingClock); workingClock = undefined; };
   let openSettings: (ctx: ExtensionContext) => Promise<void> = async () => {};
   let settingsOpen = false;
 
@@ -158,8 +158,7 @@ export default function piJar(pi: ExtensionAPI): void {
   const suggestions = new SuggestionState();
   composer.attachSuggestions(suggestions);
   const suggest = registerSuggestions(pi, suggestions, {
-    enabled: () => enabled && visualSettings.composer && visualSettings.suggestions && composer.enabled,
-    skip: () => planMode.isEnabled() || !!goals?.isActive()
+    enabled: () => enabled && visualSettings.composer && visualSettings.suggestions && composer.enabled
   });
   let liveTui: { setCopyOnSelect?: (enabled: boolean) => void } | undefined;
   /** Pi's own settings (TUI mode, copy-on-select); written through Pi's SettingsManager. */
@@ -175,8 +174,6 @@ export default function piJar(pi: ExtensionAPI): void {
   };
 
   const applyWorking = (ctx: ExtensionContext) => {
-    const active = enabled && working.phase !== "idle";
-    if (!active || !ctx.hasUI || ctx.mode !== "tui") stopWorkingClock();
     if (!ctx.hasUI || ctx.mode !== "tui") return;
     composer.setActivity(enabled ? working.phase : "idle", animations);
     try {
@@ -187,14 +184,12 @@ export default function piJar(pi: ExtensionAPI): void {
       ctx.ui.setWorkingMessage?.(view.message);
       const indicatorKey = `${working.phase}:${animations}`;
       if (indicatorKey !== workingIndicatorKey) {
-        ctx.ui.setWorkingIndicator({ frames: view.frames, intervalMs: 240 });
+        // Pi's normal streaming/tool lifecycle already causes renders. A static indicator avoids
+        // forcing the entire transcript to repaint on a timer in long sessions.
+        ctx.ui.setWorkingIndicator({ frames: [view.frames[0] ?? "✢"] });
         workingIndicatorKey = indicatorKey;
       }
-      if (active && !workingClock) {
-        workingClock = setInterval(() => applyWorking(ctx), 1000);
-        workingClock.unref?.();
-      }
-    } catch { stopWorkingClock(); /* Working decoration must never interrupt a Pi turn. */ }
+    } catch { /* Working decoration must never interrupt a Pi turn. */ }
   };
 
   const stopWelcome = (ctx?: ExtensionContext) => {
@@ -358,31 +353,20 @@ export default function piJar(pi: ExtensionAPI): void {
         welcomeStatuses = () => footerData.getExtensionStatuses();
         welcomeBranch = () => footerData.getGitBranch();
         let frame = 0;
-        let memory = `ram ${Math.round(process.memoryUsage.rss() / 1048576)} MiB`;
-        let memoryTimer: ReturnType<typeof setTimeout> | undefined;
-        const sampleMemory = () => {
-          if (disposed) return;
-          memory = `ram ${Math.round(process.memoryUsage.rss() / 1048576)} MiB`;
-          tui.requestRender();
-          memoryTimer = setTimeout(sampleMemory, 3000);
-          memoryTimer.unref?.();
-        };
-        if (footerSettings.memory) {
-          memoryTimer = setTimeout(sampleMemory, 3000);
-          memoryTimer.unref?.();
-        }
-        let timer: ReturnType<typeof setInterval> | undefined;
         let expiryTimer: ReturnType<typeof setTimeout> | undefined;
+        let expiryAt: number | undefined;
+        let memory = `ram ${Math.round(process.memoryUsage.rss() / 1048576)} MiB`;
+        let memorySampledAt = 0;
+        let context = "ctx ?";
+        let contextSampledAt = 0;
         let disposed = false;
         const unsubscribe = footerData.onBranchChange(() => tui.requestRender());
         const dispose = () => {
           if (disposed) return;
           disposed = true;
-          if (memoryTimer) clearTimeout(memoryTimer);
-          if (timer) clearInterval(timer);
           if (expiryTimer) clearTimeout(expiryTimer);
-          timer = undefined;
           expiryTimer = undefined;
+          expiryAt = undefined;
           if (footerTui === tui) { footerTui = undefined; welcomeStatuses = () => new Map<string, string>(); welcomeBranch = () => null; }
           unsubscribe();
         };
@@ -396,30 +380,44 @@ export default function piJar(pi: ExtensionAPI): void {
               const statuses = footerData.getExtensionStatuses();
               const live = collectStatuses(statuses, now);
               const roles: JarRole[] = demo ? createDemoRoles() : live.roles;
-              if (expiryTimer) clearTimeout(expiryTimer);
-              expiryTimer = undefined;
               const nearest = demo ? undefined : roles.reduce<number | undefined>((min, role) =>
                 role.expiresAt != null ? Math.min(min ?? Infinity, role.expiresAt) : min, undefined);
-              if (nearest != null) expiryTimer = setTimeout(() => tui.requestRender(), Math.max(1, nearest - now));
+              if (nearest !== expiryAt) {
+                if (expiryTimer) clearTimeout(expiryTimer);
+                expiryTimer = undefined;
+                expiryAt = nearest;
+                if (nearest != null) {
+                  expiryTimer = setTimeout(() => { expiryTimer = undefined; expiryAt = undefined; tui.requestRender(); }, Math.max(1, nearest - now));
+                  expiryTimer.unref?.();
+                }
+              }
+              // Do not schedule cosmetic footer repaints. Role state still updates on Pi's native
+              // stream/tool renders, which keeps long transcripts responsive.
               const active = animations && footerSettings.roles && roles.some((role) => ACTIVE_STATES.has(role.state));
-              if (active && !timer) timer = setInterval(() => { frame += 1; tui.requestRender(); }, 240);
-              else if (!active && timer) { clearInterval(timer); timer = undefined; }
-              const usage = ctx.getContextUsage();
-              const context = usage?.percent == null || !Number.isFinite(usage.percent)
-                ? "ctx ?" : `ctx ${Math.round(usage.percent)}%`;
+              if (active) frame++;
+              if (now - contextSampledAt >= 1000) {
+                const usage = ctx.getContextUsage();
+                context = usage?.percent == null || !Number.isFinite(usage.percent)
+                  ? "ctx ?" : `ctx ${Math.round(usage.percent)}%`;
+                contextSampledAt = now;
+              }
+              if (now - memorySampledAt >= 5000) {
+                memory = `ram ${Math.round(process.memoryUsage.rss() / 1048576)} MiB`;
+                memorySampledAt = now;
+              }
               const quota = footerSettings.quota ? quotaCache?.get(ctx.model?.provider, statuses, now) : undefined;
               return renderFooter({
                 model: ctx.model?.id ?? "no-model", effort: ctx.model?.reasoning === false ? "off" : (pi.getThinkingLevel?.() ?? "off"),
                 sessionName: ctx.sessionManager?.getSessionName?.(),
                 cwd: ctx.cwd, settings: footerSettings, branch: footerData.getGitBranch(),
-                context, goal: goalLoop.progress(), chips: footerChips(), memory, cost: formatCost(cost), quota, roles, extras: live.extras,
+                context, goal: goalLoop.progress(), chips: footerChips(),
+                memory, cost: formatCost(cost), quota, roles, extras: live.extras,
                 demo, animations, frame, motionBudget: ctx.isIdle() ? 2 : 1
               }, width, ctx.ui.theme ?? theme);
             } catch {
-              if (timer) clearInterval(timer);
               if (expiryTimer) clearTimeout(expiryTimer);
-              timer = undefined;
               expiryTimer = undefined;
+              expiryAt = undefined;
               return width > 0 ? ["pi-jar: UI unavailable (run /jar ui off)".slice(0, width)] : [];
             }
           }
@@ -478,12 +476,16 @@ export default function piJar(pi: ExtensionAPI): void {
     try { cost = sessionCost(ctx); } catch { cost = 0; }
     footerTui?.requestRender();
   };
-  const restoreTodos = (ctx: ExtensionContext) => {
-    try { todos?.restore(ctx.sessionManager.getBranch()); } catch { todos?.restore([]); }
+  const addMessageCost = (message: { usage?: { cost?: { total?: number } } }) => {
+    const value = message.usage?.cost?.total;
+    if (typeof value === "number" && Number.isFinite(value) && value >= 0) cost += value;
+  };
+  const restoreTodos = (ctx: ExtensionContext, branch?: readonly unknown[]) => {
+    try { todos?.restore(branch ?? sessionBranch(ctx)); } catch { todos?.restore([]); }
     updateTaskWidget(ctx);
   };
-  const restoreGoal = (ctx: ExtensionContext) => {
-    try { goals?.restore(ctx.sessionManager.getBranch()); } catch { goals?.restore([]); }
+  const restoreGoal = (ctx: ExtensionContext, branch?: readonly unknown[]) => {
+    try { goals?.restore(branch ?? sessionBranch(ctx)); } catch { goals?.restore([]); }
     footerTui?.requestRender();
   };
   pi.on("session_start", (_event, ctx) => {
@@ -495,7 +497,6 @@ export default function piJar(pi: ExtensionAPI): void {
     footerSettings = visualSettings.footer;
     demo = false;
     composer.disable(ctx);
-    stopWorkingClock();
     workingIndicatorKey = "";
     working.end();
     quotaCache?.stop();
@@ -506,8 +507,10 @@ export default function piJar(pi: ExtensionAPI): void {
     shells = new ShellManager(onShellEvent);
     shells.onChange = () => footerTui?.requestRender();
     goals = new GoalStore((entry) => pi.appendEntry(GOAL_ENTRY, entry));
-    restoreTodos(ctx);
-    restoreGoal(ctx);
+    let branch: readonly unknown[] = [];
+    try { branch = sessionBranch(ctx); } catch { /* keep empty */ }
+    restoreTodos(ctx, branch);
+    restoreGoal(ctx, branch);
     // Quota is enabled per session; no credentials or consent are persisted.
     quotaCache = new QuotaCache(
       (provider: QuotaProvider, signal) => fetchQuota(provider, (id) => ctx.modelRegistry.getProviderAuth(id), signal),
@@ -525,7 +528,17 @@ export default function piJar(pi: ExtensionAPI): void {
     if (visualSettings.composer && enabled) composer.enable(ctx);
     suggest.sync();
     if (visualSettings.accent !== "follow") selectAccent(ctx, visualSettings.accent);
-    showWelcome(ctx);
+    if (branch.length >= LARGE_SESSION_ENTRIES) {
+      try {
+        const prefs = piPreferences(ctx)?.get();
+        if (prefs && !prefs.fullscreen) {
+          ctx.ui.notify(`Large session (${branch.length} entries): regular TUI redraw cost grows with history. Enable Fullscreen in /jar settings for smoother rendering.`, "warning");
+        }
+      } catch { /* Performance hint is optional. */ }
+    }
+    // Resumed sessions already have a transcript to paint. Rebuilding the animated welcome and
+    // scanning other session files competes with that expensive initial render for no real benefit.
+    if (branch.length === 0) showWelcome(ctx);
   });
   // Any real prompt dismisses the welcome. Slash commands bypass `input`, so `agent_start` covers them.
   const dismissWelcome = (ctx: ExtensionContext) => {
@@ -550,6 +563,7 @@ export default function piJar(pi: ExtensionAPI): void {
   pi.on("message_end", (event, ctx) => {
     if (event.message.role === "assistant") {
       working.reportOutputTokens(event.message.usage?.output ?? 0);
+      addMessageCost(event.message);
       applyWorking(ctx);
     }
   });
@@ -558,19 +572,26 @@ export default function piJar(pi: ExtensionAPI): void {
   pi.on("ui_prompt_start", (_event, ctx) => { working.prompt(true); applyWorking(ctx); });
   pi.on("ui_prompt_end", (_event, ctx) => { working.prompt(false); applyWorking(ctx); });
   // A request may span several tool turns; keep its elapsed time and reported tokens until agent_end.
-  pi.on("turn_end", (_event, ctx) => { applyWorking(ctx); updateCost(ctx); });
+  pi.on("turn_end", (_event, ctx) => { applyWorking(ctx); });
   pi.on("agent_end", (_event, ctx) => { working.end(); applyWorking(ctx); });
   pi.on("agent_before_settle", (event) => { if (event.outcome === "error") composer.flash("error"); });
   pi.on("agent_settled", (_event, ctx) => { working.end(); applyWorking(ctx); });
-  pi.on("session_tree", (_event, ctx) => { restoreTodos(ctx); restoreGoal(ctx); updateCost(ctx); composer.refreshSession(ctx); });
+  pi.on("session_tree", (_event, ctx) => {
+    let branch: readonly unknown[] = [];
+    try { branch = sessionBranch(ctx); } catch { /* keep empty */ }
+    restoreTodos(ctx, branch);
+    restoreGoal(ctx, branch);
+    updateCost(ctx);
+    composer.refreshSession(ctx);
+  });
   pi.on("session_compact", (_event, ctx) => { restoreTodos(ctx); restoreGoal(ctx); updateCost(ctx); });
   pi.on("model_select", (_event, _ctx) => footerTui?.requestRender());
   pi.on("thinking_level_select", (_event, _ctx) => footerTui?.requestRender());
   pi.on("session_info_changed", (_event, ctx) => { composer.refreshSession(ctx); footerTui?.requestRender(); });
   pi.on("session_shutdown", (_event, ctx) => {
+    clearSessionBranchCache(ctx);
     stopWelcome(ctx);
     composer.disable(ctx);
-    stopWorkingClock();
     workingIndicatorKey = "";
     working.end();
     try { if (ctx.hasUI && ctx.mode === "tui") { ctx.ui.setWorkingMessage?.(); ctx.ui.setWorkingIndicator(); ctx.ui.setWidget("pi-jar.todos", undefined); } } catch {}
@@ -604,7 +625,7 @@ export default function piJar(pi: ExtensionAPI): void {
         earlier = (await SessionManager.list(ctx.cwd)).filter((session) => session.path !== current)
           .sort((a, b) => b.modified.getTime() - a.modified.getTime()).slice(0, 50);
       } catch (error) { ctx.ui.notify("pi-jar: earlier sessions unavailable: " + String(error), "warning"); }
-      const picked = await openPromptSearch(ctx, collectPrompts(ctx.sessionManager.getEntries(), earlier));
+      const picked = await openPromptSearch(ctx, collectPrompts(sessionBranch(ctx), earlier));
       if (picked !== undefined) ctx.ui.setEditorText(picked);
     }
   });
@@ -750,7 +771,7 @@ export default function piJar(pi: ExtensionAPI): void {
       if (command === "commit" || command.startsWith("commit ")) { await jarCommit(pi, ctx, modelRoles, sideUsage, args.trim().slice(6).trim()); return; }
       if (command === "shells") {
         if (!shells) return;
-        if (!ctx.hasUI || ctx.mode !== "tui") { ctx.ui.notify(shells.list().map((job) => `${job.id} ${job.name} ${job.status}`).join("\n") || "No background shells", "info"); return; }
+        if (!ctx.hasUI || ctx.mode !== "tui") { ctx.ui.notify(shells.summaries().map((job) => `${job.id} ${job.name} ${job.status}`).join("\n") || "No background shells", "info"); return; }
         await openShellsView(ctx, shells);
         return;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-jar",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "A warm, role-aware Pi terminal workspace with animated UI, plan and goal workflows, tasks, change review, model roles, background shells and subagents.",
   "type": "module",
   "license": "MIT",

package/src/advisor.ts

@@ -3,6 +3,7 @@ import { Type } from "typebox";
 import type { ModelRoleManager } from "./model-roles.ts";
 import { askRole, type SideUsage } from "./side-model.ts";
 import { ROLE_PREFIX } from "./status.ts";
+import { sessionBranch } from "./session-branch.ts";
 
 export const ADVISOR_TOOL = "jar_advisor";
 export const ADVISOR_MESSAGE = "pi-jar.advisor";
@@ -26,10 +27,33 @@ export const ADVISOR_SYSTEM = [
 
 type Entry = { type: string; message?: { role?: string; content?: unknown; toolName?: string; isError?: boolean; customType?: string } };
 
-const textOf = (content: unknown): string => typeof content === "string" ? content
-  : Array.isArray(content) ? content.map((part: { type?: string; text?: string; name?: string; arguments?: unknown }) =>
-    part.type === "text" ? part.text ?? "" : part.type === "toolCall" ? `[tool ${part.name} ${JSON.stringify(part.arguments ?? {}).slice(0, 300)}]` : "").filter(Boolean).join("\n")
-    : "";
+const toolHint = (args: unknown): string => {
+  if (!args || typeof args !== "object") return "";
+  const object = args as Record<string, unknown>;
+  const keys = ["command", "path", "file_path", "query", "id"];
+  for (const key of keys) {
+    const value = object[key];
+    if (typeof value === "string" && value) return `${key}=${value.slice(0, 240)}`;
+  }
+  return "";
+};
+
+const textOf = (content: unknown, limit = 4_000): string => {
+  if (typeof content === "string") return content.slice(0, limit);
+  if (!Array.isArray(content)) return "";
+  let out = "";
+  for (const part of content as Array<{ type?: string; text?: string; name?: string; arguments?: unknown }>) {
+    const piece = part.type === "text" ? part.text ?? ""
+      : part.type === "toolCall" ? `[tool ${part.name ?? "?"}${toolHint(part.arguments) ? " " + toolHint(part.arguments) : ""}]` : "";
+    if (!piece) continue;
+    const separator = out ? "\n" : "";
+    const room = limit - out.length - separator.length;
+    if (room <= 0) break;
+    out += separator + piece.slice(0, room);
+    if (piece.length > room) break;
+  }
+  return out;
+};
 
 /** The most recent conversation, newest last, capped to `limit` characters. */
 export function transcript(entries: readonly Entry[], limit = TRANSCRIPT_LIMIT): string {
@@ -38,7 +62,7 @@ export function transcript(entries: readonly Entry[], limit = TRANSCRIPT_LIMIT):
   for (let index = entries.length - 1; index >= 0 && size < limit; index--) {
     const message = entries[index]!.type === "message" ? entries[index]!.message : undefined;
     if (!message?.role) continue;
-    let body = textOf(message.content).trim();
+    let body = textOf(message.content, Math.min(4_000, limit - size)).trim();
     if (!body) continue;
     if (message.role === "toolResult" && body.length > 1200) body = body.slice(0, 1200) + " …";
     const label = message.role === "toolResult" ? `tool result (${message.toolName ?? "?"}${message.isError ? ", error" : ""})` : message.role;
@@ -118,7 +142,7 @@ export function registerAdvisor(pi: ExtensionAPI, roles: ModelRoleManager, optio
     busy++;
     status(ctx, request.trigger ?? request.question ?? "reviewing the current direction");
     try {
-      const conversation = transcript(ctx.sessionManager.getBranch() as readonly Entry[]);
+      const conversation = transcript(sessionBranch(ctx) as readonly Entry[]);
       return await askRole(ctx, roles, options.usage, "advisor", ADVISOR_SYSTEM, advisorPrompt(request, conversation, await gitState(ctx)), signal);
     } finally { if (--busy === 0) status(ctx); }
   };

package/src/animations.ts

@@ -20,4 +20,4 @@ export function roleFrame(state: RoleState, frame: number, animations = true): s
 
 export const WORKING_FRAMES = ["◇", "◆", "◇", "◈"] as const;
 /** Pixel-fire tick for the welcome flame; frozen when motion is disabled. */
-export const WELCOME_INTERVAL_MS = 90;
+export const WELCOME_INTERVAL_MS = 150;

package/src/changes.ts

@@ -4,11 +4,14 @@ import { isAbsolute, relative, resolve } from "node:path";
 /** Files larger than this, or binary files, are not tracked for review. */
 export const MAX_TRACKED_BYTES = 1024 * 1024;
 export const MAX_TRACKED_FILES = 200;
-/** Above this many (old × new) changed lines the inline diff is replaced by a summary. */
-const MAX_DIFF_CELLS = 4_000_000;
+/** Bound total retained baselines so a long editing session cannot pin hundreds of MiB. */
+export const MAX_TRACKED_TOTAL_BYTES = 8 * 1024 * 1024;
+/** Keep the quadratic fallback small; larger edits render a summary instead of allocating a huge matrix. */
+const MAX_DIFF_CELLS = 500_000;
+const MAX_DIFF_MIDDLE_LINES = 4_000;
 
 export type ChangeStatus = "added" | "modified" | "deleted";
-export interface FileChange { path: string; rel: string; status: ChangeStatus; before: string; after: string; added: number; removed: number }
+export interface FileChange { path: string; rel: string; status: ChangeStatus; before: string; after: string; added: number; removed: number; diff?: DiffOp[] | null }
 export type DiffOp = { op: " " | "+" | "-"; text: string };
 export type DiffRow = { kind: "hunk" | "context" | "add" | "remove" | "note"; text: string; oldLine?: number; newLine?: number };
 
@@ -32,10 +35,11 @@ export function lineDiff(before: string, after: string): DiffOp[] | undefined {
   let endA = a.length, endB = b.length;
   while (endA > start && endB > start && a[endA - 1] === b[endB - 1]) { endA--; endB--; }
   const midA = a.slice(start, endA), midB = b.slice(start, endB);
-  if (midA.length * midB.length > MAX_DIFF_CELLS) return undefined;
+  if (midA.length + midB.length > MAX_DIFF_MIDDLE_LINES || midA.length * midB.length > MAX_DIFF_CELLS) return undefined;
   const n = midA.length, m = midB.length;
-  // lcs[i][j] = LCS length of midA[i..] and midB[j..], flattened.
-  const lcs = new Uint32Array((n + 1) * (m + 1));
+  // lcs[i][j] = LCS length of midA[i..] and midB[j..], flattened. The matrix is
+  // intentionally capped above and Uint16 is enough because the capped middle is < 65k lines.
+  const lcs = new Uint16Array((n + 1) * (m + 1));
   for (let i = n - 1; i >= 0; i--) for (let j = m - 1; j >= 0; j--) {
     lcs[i * (m + 1) + j] = midA[i] === midB[j] ? lcs[(i + 1) * (m + 1) + j + 1]! + 1
       : Math.max(lcs[(i + 1) * (m + 1) + j]!, lcs[i * (m + 1) + j + 1]!);
@@ -95,10 +99,18 @@ export function diffRows(ops: readonly DiffOp[], context = 3): DiffRow[] {
  */
 export class ChangeTracker {
   private baselines = new Map<string, string | null>();
+  private dirty = new Set<string>();
+  private baselineBytes = 0;
   private readonly cwd: () => string;
   constructor(cwd: () => string) { this.cwd = cwd; }
 
   private absolute(path: string): string { return isAbsolute(path) ? resolve(path) : resolve(this.cwd(), path); }
+  private bytes(content: string | null): number { return content === null ? 0 : Buffer.byteLength(content, "utf8"); }
+  private drop(target: string): void {
+    if (this.baselines.has(target)) this.baselineBytes = Math.max(0, this.baselineBytes - this.bytes(this.baselines.get(target)!));
+    this.baselines.delete(target);
+    this.dirty.delete(target);
+  }
 
   /** Record the pre-change content once; returns false when the file cannot be tracked. */
   capture(path: string): boolean {
@@ -110,29 +122,58 @@ export class ChangeTracker {
     if (this.baselines.size >= MAX_TRACKED_FILES) return false;
     const content = readText(target);
     if (content === undefined) return false;
+    const bytes = this.bytes(content);
+    if (this.baselineBytes + bytes > MAX_TRACKED_TOTAL_BYTES) return false;
     this.baselines.set(target, content);
+    this.baselineBytes += bytes;
     return true;
   }
 
+  /**
+   * Mark one captured file after a successful edit/write. Do not synchronously re-read the file on
+   * every tool result; the review UI reconciles content lazily when /diff is actually opened.
+   */
+  markDirty(path: string): boolean {
+    const target = this.absolute(path);
+    if (!this.baselines.has(target)) return false;
+    this.dirty.add(target);
+    return true;
+  }
+
+  /** Materialize detailed diffs lazily for the review UI only. */
   changes(): FileChange[] {
     const result: FileChange[] = [];
-    for (const [path, before] of this.baselines) {
+    for (const path of [...this.dirty]) {
+      const before = this.baselines.get(path);
+      if (before === undefined) { this.dirty.delete(path); continue; }
       const now = readText(path);
-      if (now === undefined || now === before) continue;
+      if (now === undefined) { this.drop(path); continue; }
+      if (now === before) { this.dirty.delete(path); continue; }
       const ops = lineDiff(before ?? "", now ?? "");
-      const added = ops ? ops.filter((op) => op.op === "+").length : splitLines(now ?? "").length;
-      const removed = ops ? ops.filter((op) => op.op === "-").length : splitLines(before ?? "").length;
+      let added = 0, removed = 0;
+      if (ops) {
+        for (const op of ops) { if (op.op === "+") added++; else if (op.op === "-") removed++; }
+      } else {
+        added = splitLines(now ?? "").length;
+        removed = splitLines(before ?? "").length;
+      }
       const rel = relative(this.cwd(), path);
-      result.push({ path, rel: rel && !rel.startsWith("..") ? rel : path, status: before === null ? "added" : now === null ? "deleted" : "modified",
-        before: before ?? "", after: now ?? "", added, removed });
+      const change: FileChange = {
+        path, rel: rel && !rel.startsWith("..") ? rel : path,
+        status: before === null ? "added" : now === null ? "deleted" : "modified",
+        before: before ?? "", after: now ?? "", added, removed, diff: ops ?? null
+      };
+      result.push(change);
     }
     return result.sort((a, b) => a.rel.localeCompare(b.rel));
   }
 
-  count(): number { return this.changes().length; }
+  /** O(1): the footer never calculates file diffs just to show its badge. */
+  count(): number { return this.dirty.size; }
+  trackedBytes(): number { return this.baselineBytes; }
   /** Keep the current content: stop tracking the file. */
-  accept(path: string): void { this.baselines.delete(this.absolute(path)); }
-  acceptAll(): void { this.baselines.clear(); }
+  accept(path: string): void { this.drop(this.absolute(path)); }
+  acceptAll(): void { this.baselines.clear(); this.dirty.clear(); this.baselineBytes = 0; }
   /** Restore the pre-change content (or remove a file the agent created). */
   revert(path: string): void {
     const target = this.absolute(path);
@@ -140,7 +181,7 @@ export class ChangeTracker {
     const before = this.baselines.get(target)!;
     if (before === null) { if (existsSync(target)) unlinkSync(target); }
     else writeFileSync(target, before);
-    this.baselines.delete(target);
+    this.drop(target);
   }
-  clear(): void { this.baselines.clear(); }
+  clear(): void { this.acceptAll(); }
 }

package/src/compact-tools.ts

@@ -12,12 +12,42 @@ import { Text } from "@earendil-works/pi-tui";
 
 type ToolResult = { content: Array<{ type: string; text?: string }>; details?: unknown };
 
-const outputText = (result: ToolResult): string => result.content
-  .filter((item) => item.type === "text" && typeof item.text === "string")
-  .map((item) => item.text!)
-  .join("\n");
+const SUMMARY_SCAN_CHARS = 32 * 1024;
+const DIFF_SCAN_CHARS = 64 * 1024;
+const resultSummaryCache = new WeakMap<object, { sample: string; lines: number; truncated: boolean }>();
+const writeCountCache = new WeakMap<object, { lines: number; truncated: boolean }>();
+
+function summarizeResult(result: ToolResult): { sample: string; lines: number; truncated: boolean } {
+  if (result && typeof result === "object") {
+    const cached = resultSummaryCache.get(result as object);
+    if (cached) return cached;
+  }
+  let sample = "";
+  let truncated = false;
+  let textParts = 0;
+  for (const item of result.content) {
+    if (item.type !== "text" || typeof item.text !== "string") continue;
+    if (textParts++ && sample.length < SUMMARY_SCAN_CHARS) sample += "\n";
+    const room = SUMMARY_SCAN_CHARS - sample.length;
+    if (room <= 0) { truncated = true; break; }
+    sample += item.text.slice(0, room);
+    if (item.text.length > room) { truncated = true; break; }
+  }
+  const value = { sample, lines: sample ? sample.split("\n").length : 0, truncated };
+  if (result && typeof result === "object") resultSummaryCache.set(result as object, value);
+  return value;
+}
+
+function firstNonEmpty(text: string): string {
+  for (const line of text.split("\n")) if (line.trim()) return line;
+  return "";
+}
+
+function boundedLineCount(text: string, limit = SUMMARY_SCAN_CHARS): { lines: number; truncated: boolean } {
+  const sample = text.slice(0, limit);
+  return { lines: sample ? sample.split("\n").length : 0, truncated: text.length > limit };
+}
 
-const nonEmptyLines = (text: string): string[] => text.split("\n").filter((line) => line.trim().length > 0);
 const expandHint = " · [ expand ] Ctrl+O";
 
 function compactText(text: string, max = 72): string {
@@ -25,12 +55,18 @@ function compactText(text: string, max = 72): string {
   return clean.length <= max ? clean : clean.slice(0, Math.max(0, max - 1)) + "…";
 }
 
+const bashCache = new WeakMap<object, { cwd: string; trusted: boolean; tool: ReturnType<typeof createBashToolDefinition> }>();
 function bashFor(ctx: ExtensionContext) {
-  const settings = SettingsManager.create(ctx.cwd, getAgentDir(), { projectTrusted: ctx.isProjectTrusted() });
-  return createBashToolDefinition(ctx.cwd, {
+  const trusted = ctx.isProjectTrusted();
+  const hit = bashCache.get(ctx as object);
+  if (hit && hit.cwd === ctx.cwd && hit.trusted === trusted) return hit.tool;
+  const settings = SettingsManager.create(ctx.cwd, getAgentDir(), { projectTrusted: trusted });
+  const tool = createBashToolDefinition(ctx.cwd, {
     shellPath: settings.getShellPath(),
     commandPrefix: settings.getShellCommandPrefix()
   });
+  bashCache.set(ctx as object, { cwd: ctx.cwd, trusted, tool });
+  return tool;
 }
 
 /**
@@ -58,9 +94,9 @@ export function installCompactBuiltinTools(pi: ExtensionAPI): void {
     renderResult(result, options, theme, context) {
       if (options.expanded && read.renderResult) return read.renderResult(result, options, theme, context);
       if (options.isPartial) return new Text(theme.fg("warning", "reading…"), 0, 0);
-      const text = outputText(result);
-      const count = text ? text.split("\n").length : 0;
-      return new Text(theme.fg("muted", `${count} line${count === 1 ? "" : "s"}${expandHint}`), 0, 0);
+      const summary = summarizeResult(result);
+      const count = `${summary.lines}${summary.truncated ? "+" : ""}`;
+      return new Text(theme.fg("muted", `${count} line${summary.lines === 1 && !summary.truncated ? "" : "s"}${expandHint}`), 0, 0);
     }
   });
 
@@ -75,12 +111,13 @@ export function installCompactBuiltinTools(pi: ExtensionAPI): void {
     },
     renderResult(result, options, theme, context) {
       if (options.expanded && bash.renderResult) return bash.renderResult(result as Parameters<NonNullable<typeof bash.renderResult>>[0], options, theme, context);
-      const text = outputText(result);
-      const lines = nonEmptyLines(text);
-      const preview = lines[0] ? ` · ${compactText(lines[0], 56)}` : "";
+      const summary = summarizeResult(result);
+      const first = firstNonEmpty(summary.sample);
+      const preview = first ? ` · ${compactText(first, 56)}` : "";
+      const count = `${summary.lines}${summary.truncated ? "+" : ""}`;
       const label = options.isPartial ? "running" : "done";
       return new Text(theme.fg(options.isPartial ? "warning" : "muted",
-        `${label} · ${lines.length} line${lines.length === 1 ? "" : "s"}${preview}${expandHint}`), 0, 0);
+        `${label} · ${count} line${summary.lines === 1 && !summary.truncated ? "" : "s"}${preview}${expandHint}`), 0, 0);
     }
   });
 
@@ -96,9 +133,11 @@ export function installCompactBuiltinTools(pi: ExtensionAPI): void {
       const details = result.details as { diff?: string } | undefined;
       const diff = details?.diff ?? "";
       if (!diff) {
-        const text = outputText(result);
+        const summary = summarizeResult(result);
+        const text = summary.sample;
         return new Text(theme.fg(text.startsWith("Error") ? "error" : "success", compactText(text || "applied", 96)), 0, 0);
       }
+      if (diff.length > DIFF_SCAN_CHARS) return new Text(theme.fg("muted", `large diff${expandHint}`), 0, 0);
       let additions = 0;
       let removals = 0;
       for (const line of diff.split("\n")) {
@@ -114,14 +153,19 @@ export function installCompactBuiltinTools(pi: ExtensionAPI): void {
     ...write,
     renderCall(args, theme, context) {
       if (context.expanded && write.renderCall) return write.renderCall(args, theme, context);
-      const count = args.content.split("\n").length;
+      let count = args && typeof args === "object" ? writeCountCache.get(args as object) : undefined;
+      if (!count) {
+        count = boundedLineCount(args.content);
+        if (args && typeof args === "object") writeCountCache.set(args as object, count);
+      }
       return new Text(theme.fg("toolTitle", theme.bold("write ")) + theme.fg("accent", args.path)
-        + theme.fg("dim", ` · ${count} lines`), 0, 0);
+        + theme.fg("dim", ` · ${count.lines}${count.truncated ? "+" : ""} lines`), 0, 0);
     },
     renderResult(result, options, theme, context) {
       if (options.expanded && write.renderResult) return write.renderResult(result, options, theme, context);
       if (options.isPartial) return new Text(theme.fg("warning", "writing…"), 0, 0);
-      const text = outputText(result);
+      const summary = summarizeResult(result);
+      const text = summary.sample;
       return new Text(theme.fg(text.startsWith("Error") ? "error" : "success", compactText(text || "written", 96))
         + theme.fg("dim", text ? expandHint : ""), 0, 0);
     }