pi-jar 0.1.1 → 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: 600 });
+        // 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,32 +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 MEMORY_SAMPLE_MS = 10_000;
-        const sampleMemory = () => {
-          if (disposed) return;
-          const next = `ram ${Math.round(process.memoryUsage.rss() / 1048576)} MiB`;
-          if (next !== memory) { memory = next; tui.requestRender(); }
-          memoryTimer = setTimeout(sampleMemory, MEMORY_SAMPLE_MS);
-          memoryTimer.unref?.();
-        };
-        if (footerSettings.memory) {
-          memoryTimer = setTimeout(sampleMemory, MEMORY_SAMPLE_MS);
-          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();
         };
@@ -397,32 +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(); }, 600);
-                timer.unref?.();
-              } 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)] : [];
             }
           }
@@ -481,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) => {
@@ -498,7 +497,6 @@ export default function piJar(pi: ExtensionAPI): void {
     footerSettings = visualSettings.footer;
     demo = false;
     composer.disable(ctx);
-    stopWorkingClock();
     workingIndicatorKey = "";
     working.end();
     quotaCache?.stop();
@@ -509,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),
@@ -528,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) => {
@@ -553,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);
     }
   });
@@ -561,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 {}
@@ -607,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);
     }
   });
@@ -753,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.1",
+  "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/changes.ts

@@ -100,7 +100,6 @@ 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 diffCache = new Map<string, FileChange>();
   private baselineBytes = 0;
   private readonly cwd: () => string;
   constructor(cwd: () => string) { this.cwd = cwd; }
@@ -111,7 +110,6 @@ export class ChangeTracker {
     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);
-    this.diffCache.delete(target);
   }
 
   /** Record the pre-change content once; returns false when the file cannot be tracked. */
@@ -132,20 +130,12 @@ export class ChangeTracker {
   }
 
   /**
-   * Mark one captured file after an edit/write completes. This performs only one cheap file read;
-   * no line diff is calculated until the review UI is opened.
+   * 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;
-    const before = this.baselines.get(target)!;
-    const now = readText(target);
-    this.diffCache.delete(target);
-    if (now === undefined) { this.drop(target); return false; }
-    if (now === before) {
-      this.dirty.delete(target);
-      return false;
-    }
     this.dirty.add(target);
     return true;
   }
@@ -155,22 +145,24 @@ export class ChangeTracker {
     const result: FileChange[] = [];
     for (const path of [...this.dirty]) {
       const before = this.baselines.get(path);
-      if (before === undefined) { this.dirty.delete(path); this.diffCache.delete(path); continue; }
+      if (before === undefined) { this.dirty.delete(path); continue; }
       const now = readText(path);
       if (now === undefined) { this.drop(path); continue; }
-      if (now === before) { this.dirty.delete(path); this.diffCache.delete(path); continue; }
-      const cached = this.diffCache.get(path);
-      if (cached) { result.push(cached); 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);
       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
       };
-      this.diffCache.set(path, change);
       result.push(change);
     }
     return result.sort((a, b) => a.rel.localeCompare(b.rel));
@@ -181,7 +173,7 @@ export class ChangeTracker {
   trackedBytes(): number { return this.baselineBytes; }
   /** Keep the current content: stop tracking the file. */
   accept(path: string): void { this.drop(this.absolute(path)); }
-  acceptAll(): void { this.baselines.clear(); this.dirty.clear(); this.diffCache.clear(); this.baselineBytes = 0; }
+  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);

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

package/src/composer.ts

@@ -280,7 +280,8 @@ export class ComposerStyle {
     tip: (width) => {
       if (!this.mascotOn || width < 40) return undefined;
       const mood = this.animations ? this.mascot.mood() : "idle";
-      const tip = this.animations ? this.mascot.tip(Date.now(), this.frame) : this.mascot.tip(0, 0);
+      const animationFrame = this.phase === "idle" ? this.frame : Math.floor(Date.now() / COMPOSER_ACTIVE_INTERVAL_MS);
+      const tip = this.animations ? this.mascot.tip(Date.now(), animationFrame) : this.mascot.tip(0, 0);
       return " ".repeat(3) + paintTip(tip, mood, this.colors ? (color, text) => this.colors!.fg(color, text) : undefined);
     },
     session: () => this.session,
@@ -335,8 +336,9 @@ export class ComposerStyle {
   }
 
   /**
-   * Active motion ticks at a modest 600 ms. Idle motion has no polling loop at all: it sleeps
-   * until the mascot's next blink/sleep/flash deadline, then schedules the following deadline.
+   * Pi's own streaming/tool updates already repaint active sessions. Never add another active
+   * animation loop: active frames derive from wall time when Pi naturally renders. Idle only
+   * schedules exact blink/sleep/flash transitions.
    */
   private restartTimer(): void {
     this.stopTimer();
@@ -346,8 +348,7 @@ export class ComposerStyle {
   }
   private scheduleTimer(): void {
     if (!this.enabled || !this.animations || !this.mascotOn || this.timer) return;
-    const active = this.phase === "generating" || this.phase === "tool" || this.phase === "waiting";
-    const delay = active ? COMPOSER_ACTIVE_INTERVAL_MS : this.mascot.nextTransitionDelay(Date.now());
+    const delay = this.mascot.nextTransitionDelay(Date.now());
     if (delay === undefined) return;
     this.timer = setTimeout(() => {
       this.timer = undefined;