pi-jar 0.1.1 → 0.1.2

package/src/delegate.ts

@@ -15,7 +15,9 @@ export const MAX_DELEGATES = 4;
 export const READ_ONLY_TOOLS = ["read", "grep", "find", "ls"] as const;
 const MAX_OUTPUT_CHARS = 12_000;
 const TIMEOUT_MS = 20 * 60_000;
-const STATUS_REFRESH_MS = 10_000;
+const STATUS_REFRESH_MS = 20_000;
+const LIVE_UPDATE_MS = 1000;
+const MAX_EVENT_TEXT = 16_000;
 
 export type DelegateState = "queued" | "working" | "done" | "failed";
 export interface DelegateRun {
@@ -56,9 +58,20 @@ export function delegateArgs(task: string, model: string | undefined, thinking:
   return args;
 }
 
-const textOf = (message: { content?: unknown }) => Array.isArray(message.content)
-  ? message.content.filter((part: { type?: string }) => part?.type === "text").map((part: { text?: string }) => part.text ?? "").join("\n")
-  : typeof message.content === "string" ? message.content : "";
+const textOf = (message: { content?: unknown }, limit = MAX_EVENT_TEXT): string => {
+  if (typeof message.content === "string") return message.content.slice(0, limit);
+  if (!Array.isArray(message.content)) return "";
+  let out = "";
+  for (const part of message.content as Array<{ type?: string; text?: string }>) {
+    if (part?.type !== "text" || typeof part.text !== "string" || !part.text) continue;
+    const separator = out ? "\n" : "";
+    const room = limit - out.length - separator.length;
+    if (room <= 0) break;
+    out += separator + part.text.slice(0, room);
+    if (part.text.length > room) break;
+  }
+  return out;
+};
 
 /** Run one child Pi, feeding progress into `run` and calling `update` on every change. */
 export function runDelegate(run: DelegateRun, args: string[], cwd: string, signal: AbortSignal | undefined, update: () => void, spawnProcess: Spawn = spawn as Spawn): Promise<void> {
@@ -171,20 +184,36 @@ export function registerDelegate(pi: ExtensionAPI, roles: ModelRoleManager, spaw
           } catch { /* status is decoration */ }
         }
       };
-      const details = () => ({ runs: runs.map((run) => ({ ...run })), write });
-      const update = () => {
+      const details = (includeOutput = true) => ({ runs: runs.map((run) => includeOutput ? { ...run } : { ...run, output: "" }), write });
+      let updateTimer: ReturnType<typeof setTimeout> | undefined;
+      let lastUpdateAt = 0;
+      const emitUpdate = () => {
+        updateTimer = undefined;
+        lastUpdateAt = Date.now();
         publish();
-        onUpdate?.({ content: [{ type: "text", text: runs.map((run) => `${run.name}: ${run.state}`).join("\n") }], details: details() });
+        onUpdate?.({ content: [{ type: "text", text: runs.map((run) => `${run.name}: ${run.state}`).join("\n") }], details: details(false) });
+      };
+      const update = () => {
+        if (!onUpdate) { publish(); return; }
+        const wait = Math.max(0, LIVE_UPDATE_MS - (Date.now() - lastUpdateAt));
+        if (wait === 0) { if (updateTimer) { clearTimeout(updateTimer); updateTimer = undefined; } emitUpdate(); return; }
+        if (!updateTimer) {
+          updateTimer = setTimeout(emitUpdate, wait);
+          updateTimer.unref?.();
+        }
+      };
+      const flushUpdate = () => {
+        if (updateTimer) { clearTimeout(updateTimer); updateTimer = undefined; }
+        emitUpdate();
       };
       const refresh = setInterval(publish, STATUS_REFRESH_MS);
       refresh.unref?.();
       try {
-        update();
         await Promise.all(runs.map((run) => runDelegate(run, delegateArgs(run.task, run.model, thinking(run.role), write), ctx.cwd, signal, update, spawnProcess)));
       } finally {
         clearInterval(refresh);
         for (const run of runs) if (run.state !== "done") run.state = "failed";
-        publish();
+        flushUpdate();
       }
       const report = runs.map((run) => `## [${run.index}] ${run.name} (${run.role}${run.model ? " · " + run.model : ""}) — ${run.state}${run.error ? ": " + run.error : ""}\n${run.output || "(no report)"}`).join("\n\n");
       return { content: [{ type: "text", text: report }], details: details() };

package/src/diff-view.ts

@@ -167,8 +167,8 @@ export function registerChangeReview(pi: ExtensionAPI, tracker: () => ChangeTrac
       }
     }
     if (!path) path = fallback.shift();
-    if (path) tracker()?.markDirty(path);
-    changed();
+    const failed = (event as { isError?: unknown }).isError === true;
+    if (path && !failed && tracker()?.markDirty(path)) changed();
   });
   const open = async (ctx: ExtensionContext) => {
     const current = tracker();

package/src/goal-loop.ts

@@ -45,6 +45,7 @@ export class GoalLoop {
   private readonly pi: ExtensionAPI;
   private readonly options: GoalLoopOptions;
   private prompting = 0;
+  private contextDirty = true;
   private restoreRole: (() => Promise<void>) | undefined;
   private roleInUse: "implement" | "advisor" | undefined;
 
@@ -63,6 +64,7 @@ export class GoalLoop {
     const store = this.options.goals();
     if (!store?.isActive()) return;
     store.setStatus("paused", { reason });
+    this.contextDirty = true;
     if (ctx) { ctx.ui.notify("◎ Goal paused · " + reason + " · /goal resume", "info"); this.options.changed?.(ctx); }
   }
 
@@ -127,6 +129,7 @@ export class GoalLoop {
     if (goal.phase !== "audit") return { ok: false, message: "Cannot complete yet: finish your turn; pi-jar runs an audit pass before a goal can be completed." };
     if (!evidence.trim()) return { ok: false, message: "Provide concrete evidence (commands run, results, files) to complete the goal." };
     if (!store.setStatus("complete", { evidence })) return { ok: false, message: "Could not record goal completion." };
+    this.contextDirty = true;
     ctx.ui.notify("◎ Goal complete · " + goal.text, "info");
     this.options.changed?.(ctx);
     this.options.completed?.(ctx, { ...goal, status: "complete", evidence });
@@ -138,6 +141,7 @@ export class GoalLoop {
     const store = this.options.goals();
     if (!store) { ctx.ui.notify("Goal state is unavailable before the session starts", "warning"); return; }
     if (!store.set(text)) { ctx.ui.notify("Could not set goal; keep it concise and plain-text", "error"); return; }
+    this.contextDirty = true;
     this.options.changed?.(ctx);
     ctx.ui.notify("◎ Goal active · " + store.current()!.text, "info");
     if (this.options.planActive()) { this.pause(ctx, "plan mode is on"); return; }
@@ -174,6 +178,7 @@ export class GoalLoop {
           if (!goal || goal.status !== "active") return { content: [{ type: "text", text: "No active goal." }], details: { action: "block", ok: false } };
           const reason = (params.reason ?? "").trim() || "needs user input";
           this.options.goals()?.setStatus("paused", { reason });
+          this.contextDirty = true;
           ctx.ui.notify("◎ Goal blocked · " + reason, "warning");
           this.options.changed?.(ctx);
           return { content: [{ type: "text", text: "Goal paused for the user: " + reason }], details: { action: "block", ok: true }, terminate: true };
@@ -198,7 +203,7 @@ export class GoalLoop {
         const verb = raw.toLowerCase();
         if (/^(?:clear|off|none|drop)$/.test(verb)) {
           await this.restore();
-          if (store.clear()) { this.options.changed?.(ctx); ctx.ui.notify("Goal cleared", "info"); }
+          if (store.clear()) { this.contextDirty = true; this.options.changed?.(ctx); ctx.ui.notify("Goal cleared", "info"); }
           return;
         }
         if (verb === "pause") { this.pause(ctx, "paused by you"); return; }
@@ -208,6 +213,7 @@ export class GoalLoop {
           if (this.options.planActive()) { ctx.ui.notify("Leave plan mode before resuming the goal", "warning"); return; }
           store.setStatus("active");
           store.setRound(0, goal.phase);
+          this.contextDirty = true;
           this.options.changed?.(ctx);
           this.pi.sendUserMessage("Resume work on the active goal: " + goal.text, { deliverAs: "followUp" });
           return;
@@ -257,21 +263,37 @@ export class GoalLoop {
       const goal = this.goal();
       if (!goal || goal.status === "complete") return;
       if (goal.status === "active" && !this.options.planActive()) await this.useRole(goal.phase === "audit" ? "advisor" : "implement", ctx);
+      this.contextDirty = true;
       return { message: { customType: CONTEXT_TYPE, content: this.context(goal), display: false } };
     });
 
-    // Keep only the newest goal context and continuation so repeated rounds do not bloat the prompt.
+    // Keep only the newest goal context and continuation. Scan in place first and allocate a new
+    // message array only when stale pi-jar messages actually need pruning.
     this.pi.on("context", async (event) => {
+      if (!this.contextDirty) return;
       const goal = this.goal();
-      const seen = new Set<string>();
-      const messages = [...event.messages].reverse().filter((raw) => {
+      const active = !!goal && goal.status !== "complete";
+      let latestContext = -1;
+      let latestContinuation = -1;
+      let needsPrune = false;
+      for (let index = event.messages.length - 1; index >= 0; index--) {
+        const type = (event.messages[index] as { customType?: string }).customType;
+        if (type === CONTEXT_TYPE) {
+          if (!active || latestContext >= 0) needsPrune = true;
+          else latestContext = index;
+        } else if (type === CONTINUATION_TYPE) {
+          if (!active || latestContinuation >= 0) needsPrune = true;
+          else latestContinuation = index;
+        }
+      }
+      this.contextDirty = false;
+      if (!needsPrune) return;
+      return { messages: event.messages.filter((raw, index) => {
         const type = (raw as { customType?: string }).customType;
-        if (type !== CONTEXT_TYPE && type !== CONTINUATION_TYPE) return true;
-        if (!goal || goal.status === "complete" || seen.has(type)) return false;
-        seen.add(type);
+        if (type === CONTEXT_TYPE) return active && index === latestContext;
+        if (type === CONTINUATION_TYPE) return active && index === latestContinuation;
         return true;
-      }).reverse();
-      return { messages };
+      }) };
     });
 
     this.pi.on("agent_before_settle", async (event, ctx) => {
@@ -295,6 +317,7 @@ export class GoalLoop {
       store.setRound(round, audit ? "audit" : "implement");
       await this.useRole(audit ? "advisor" : "implement", ctx);
       this.options.changed?.(ctx);
+      this.contextDirty = true;
       return {
         entries: [{ type: "custom_message", customType: CONTINUATION_TYPE, display: false,
           content: audit ? this.auditMessage(goal, round) : this.implementMessage(goal, round) }],
@@ -308,6 +331,8 @@ export class GoalLoop {
       this.options.changed?.(ctx);
     });
 
+    this.pi.on("session_start", () => { this.contextDirty = true; });
+    this.pi.on("session_tree", () => { this.contextDirty = true; });
     this.pi.on("session_shutdown", async () => { await this.restore(); });
   }
 }

package/src/goals.ts

@@ -72,11 +72,22 @@ export class GoalStore {
 
   restore(branch: readonly unknown[]): void {
     this.value = undefined;
-    for (const raw of branch) {
+    // Collect only goal events while walking backward; stop at the newest valid set/clear
+    // checkpoint, then replay that tiny list forward.
+    const replay: unknown[] = [];
+    for (let index = branch.length - 1; index >= 0; index--) {
+      const raw = branch[index];
       if (!raw || typeof raw !== "object") continue;
       const entry = raw as Record<string, unknown>;
-      if (entry.type === "custom" && entry.customType === GOAL_ENTRY) this.apply(entry.data);
+      if (entry.type !== "custom" || entry.customType !== GOAL_ENTRY || !entry.data || typeof entry.data !== "object") continue;
+      const data = entry.data as Record<string, unknown>;
+      replay.push(data);
+      const validCheckpoint = data.op === "clear" && data.v === 1
+        || data.op === "set" && ((data.v === 1 && validGoal(data.text))
+          || (data.v === 2 && validId(data.id) && validGoal(data.text)));
+      if (validCheckpoint) break;
     }
+    for (let index = replay.length - 1; index >= 0; index--) this.apply(replay[index]);
   }
 
   private commit(event: GoalEvent): boolean {

package/src/history-ui.ts

@@ -1,12 +1,13 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Input, Key, matchesKey, truncateToWidth, visibleWidth, type TuiMouseEvent } from "@earendil-works/pi-tui";
 import { createHistorySnapshot, historyChunk, historyPage, safeHistoryText, type HistoryItem } from "./history.ts";
+import { sessionBranch } from "./session-branch.ts";
 
 /** Separate, read-only view. Pi's native transcript and session file are never modified. */
 export async function openJarHistory(ctx: ExtensionContext): Promise<void> {
   if (!ctx.hasUI || ctx.mode !== "tui") return;
   // Capture the active branch ONCE on open. Paging and search operate on this snapshot.
-  const snapshot = createHistorySnapshot(ctx.sessionManager.getBranch());
+  const snapshot = createHistorySnapshot(sessionBranch(ctx) as ReturnType<typeof ctx.sessionManager.getBranch>);
   await ctx.ui.custom<void>((tui, theme, _keys, done) => {
     let current = historyPage(snapshot);
     let selected = Math.max(0, current.items.length - 1);

package/src/info-panels.ts

@@ -4,6 +4,7 @@ import { openPanel, type PanelTab } from "./panel.ts";
 import type { Quota } from "./quota.ts";
 import type { SideUsage } from "./side-model.ts";
 import { collectUsage, usageLines } from "./usage-view.ts";
+import { sessionBranch } from "./session-branch.ts";
 
 /** Pi's default compaction reserve, used when its settings cannot be read. */
 const DEFAULT_RESERVE = 16_384;
@@ -52,14 +53,25 @@ export function registerInfoPanels(pi: ExtensionAPI, deps: InfoPanelDeps): void
   });
   pi.on("session_start", () => { parts = undefined; });
   const tabs = (ctx: ExtensionContext): PanelTab[] => {
-    const context = contextFor(pi, ctx, parts);
+    // These panels can scan a large branch/projection. Snapshot each expensive view once per
+    // panel open, lazily on first render, so scrolling/resizing does not repeat O(history) work.
+    let usage: ReturnType<typeof collectUsage> | undefined;
+    let context: ReturnType<typeof contextFor> | undefined;
     return [
-      { name: "Usage", render: (width, fg) => usageLines({
-        stats: collectUsage(ctx.sessionManager.getBranch() as never, deps.side.all()),
-        ...(ctx.model?.provider ? { provider: ctx.model.provider } : {}),
-        ...(deps.quota(ctx) ? { quota: deps.quota(ctx)! } : {}),
-        quotaEnabled: deps.quotaEnabled(), now: Date.now() }, width, fg) },
-      { name: "Context", render: (width, fg) => contextLines(context, width, fg) }
+      { name: "Usage", render: (width, fg) => {
+        usage ??= collectUsage(sessionBranch(ctx) as never, deps.side.all());
+        const quota = deps.quota(ctx);
+        return usageLines({
+          stats: usage,
+          ...(ctx.model?.provider ? { provider: ctx.model.provider } : {}),
+          ...(quota ? { quota } : {}),
+          quotaEnabled: deps.quotaEnabled(), now: Date.now()
+        }, width, fg);
+      } },
+      { name: "Context", render: (width, fg) => {
+        context ??= contextFor(pi, ctx, parts);
+        return contextLines(context, width, fg);
+      } }
     ];
   };
   const plain = (_color: string, text: string) => text;

package/src/plan.ts

@@ -9,6 +9,7 @@ import { type ModelRoleManager } from "./model-roles.ts";
 import { openPlanView } from "./plan-view.ts";
 import { extractApproachSteps, isSafePlanCommand, PLAN_TEMPLATE, planTextFromSteps, validatePlanDocument } from "./plan-utils.ts";
 import { cleanText } from "./status.ts";
+import { sessionBranch } from "./session-branch.ts";
 import { type TodoStore } from "./tasks.ts";
 
 export const PLAN_ENTRY = "pi-jar.plan";
@@ -135,6 +136,7 @@ export class PlanMode {
     try { this.ensureDirectory(ctx); }
     catch (error) { ctx.ui.notify("Plan mode unavailable: cannot create plan directory: " + (error as Error).message, "error"); return; }
     this.enabled = true;
+    this.contextDirty = true;
     this.pendingReview = false;
     this.reminders = 0;
     this.toolsBefore = this.pi.getActiveTools();
@@ -149,6 +151,7 @@ export class PlanMode {
   private async leave(ctx: ExtensionContext, persist = true): Promise<void> {
     const wasEnabled = this.enabled;
     this.enabled = false;
+    this.contextDirty = true;
     this.compacting = false;
     this.pendingReview = false;
     this.compactGeneration++;
@@ -293,14 +296,16 @@ export class PlanMode {
   }
 
   private restoreFrom(branch: readonly unknown[]): PlanState | undefined {
-    let state: PlanState | undefined;
-    for (const raw of branch) {
+    // Only the newest persisted plan state matters. Walk backward so resuming a long session
+    // does not inspect every historical transcript entry.
+    for (let index = branch.length - 1; index >= 0; index--) {
+      const raw = branch[index];
       if (!raw || typeof raw !== "object") continue;
       const entry = raw as Record<string, unknown>;
       if (entry.type !== "custom" || entry.customType !== PLAN_ENTRY || !entry.data || typeof entry.data !== "object") continue;
       const data = entry.data as Record<string, unknown>;
       if ((data.v !== 1 && data.v !== 2) || typeof data.enabled !== "boolean" || !Array.isArray(data.steps)) continue;
-      state = {
+      return {
         v: 2, enabled: data.enabled,
         steps: data.steps.filter((item): item is string => typeof item === "string").map((item) => cleanText(item, 240)).filter(Boolean).slice(0, 50),
         text: typeof data.text === "string" ? safePlanText(data.text) : "",
@@ -308,7 +313,7 @@ export class PlanMode {
         ...(typeof data.title === "string" ? { title: cleanText(data.title, 120) } : {})
       };
     }
-    return state;
+    return undefined;
   }
 
   private async restore(branch: readonly unknown[], ctx: ExtensionContext): Promise<void> {
@@ -411,14 +416,34 @@ export class PlanMode {
 
     this.pi.on("before_agent_start", async () => {
       if (!this.enabled) return;
+      this.contextDirty = true;
       return { message: { customType: "pi-jar.plan-context", content: this.context(), display: false } };
     });
 
+    // Keep plan-only prompt messages bounded. When plan mode is active, retain only the newest
+    // context and newest reminder; when it is off, remove all stale plan prompt messages.
     this.pi.on("context", async (event) => {
-      if (this.enabled) return;
-      return { messages: event.messages.filter((raw) => {
-        const message = raw as { customType?: string };
-        return message.customType !== "pi-jar.plan-context" && message.customType !== "pi-jar.plan-reminder";
+      if (!this.contextDirty) return;
+      let latestContext = -1;
+      let latestReminder = -1;
+      let needsPrune = false;
+      for (let index = event.messages.length - 1; index >= 0; index--) {
+        const type = (event.messages[index] as { customType?: string }).customType;
+        if (type === "pi-jar.plan-context") {
+          if (!this.enabled || latestContext >= 0) needsPrune = true;
+          else latestContext = index;
+        } else if (type === "pi-jar.plan-reminder") {
+          if (!this.enabled || latestReminder >= 0) needsPrune = true;
+          else latestReminder = index;
+        }
+      }
+      this.contextDirty = false;
+      if (!needsPrune) return;
+      return { messages: event.messages.filter((raw, index) => {
+        const type = (raw as { customType?: string }).customType;
+        if (type === "pi-jar.plan-context") return this.enabled && index === latestContext;
+        if (type === "pi-jar.plan-reminder") return this.enabled && index === latestReminder;
+        return true;
       }) };
     });
 
@@ -434,6 +459,7 @@ export class PlanMode {
         return;
       }
       this.reminders++;
+      this.contextDirty = true;
       return {
         entries: [{ type: "custom_message", customType: "pi-jar.plan-reminder", display: false,
           content: `[PI-JAR PLAN MODE] You ended the turn without ${PLAN_SUBMIT_TOOL}. If the plan is ready, write it to the plan directory and call ${PLAN_SUBMIT_TOOL}. If you need a decision from the user, use jar_ask. Do not ask for approval in chat.` }],
@@ -453,8 +479,8 @@ export class PlanMode {
       if (this.enabled && this.pendingReview) await this.review(ctx);
     });
 
-    this.pi.on("session_start", async (_event, ctx) => { await this.restore(ctx.sessionManager.getBranch(), ctx); });
-    this.pi.on("session_tree", async (_event, ctx) => { await this.restore(ctx.sessionManager.getBranch(), ctx); });
+    this.pi.on("session_start", async (_event, ctx) => { this.contextDirty = true; await this.restore(sessionBranch(ctx), ctx); });
+    this.pi.on("session_tree", async (_event, ctx) => { this.contextDirty = true; await this.restore(sessionBranch(ctx), ctx); });
     this.pi.on("session_shutdown", async (_event, ctx) => { if (this.enabled) await this.leave(ctx, false); });
   }
 }

package/src/prompt-search.ts

@@ -4,8 +4,21 @@ import { cleanText } from "./status.ts";
 
 export interface PastPrompt { text: string; source: "this session" | "earlier session"; at?: number }
 
-const userText = (message: { content?: unknown }) => typeof message.content === "string" ? message.content
-  : Array.isArray(message.content) ? message.content.filter((part: { type?: string }) => part?.type === "text").map((part: { text?: string }) => part.text ?? "").join("\n") : "";
+const MAX_PROMPT_CHARS = 8000;
+const userText = (message: { content?: unknown }): string => {
+  if (typeof message.content === "string") return message.content.slice(0, MAX_PROMPT_CHARS + 1);
+  if (!Array.isArray(message.content)) return "";
+  let text = "";
+  for (const part of message.content as Array<{ type?: string; text?: string }>) {
+    if (part?.type !== "text" || typeof part.text !== "string") continue;
+    const separator = text ? "\n" : "";
+    const room = MAX_PROMPT_CHARS + 1 - text.length - separator.length;
+    if (room <= 0) break;
+    text += separator + part.text.slice(0, room);
+    if (part.text.length > room) break;
+  }
+  return text;
+};
 
 /**
  * Prompts newest first and deduplicated: every user message in this session file (all branches),
@@ -17,13 +30,17 @@ export function collectPrompts(entries: readonly unknown[], earlier: readonly {
   const add = (text: string, source: PastPrompt["source"], at?: number) => {
     const value = text.trim();
     const key = value.replace(/\s+/g, " ");
-    if (!value || value.length > 8000 || seen.has(key)) return;
+    if (!value || value.length > MAX_PROMPT_CHARS || seen.has(key)) return;
     seen.add(key);
     result.push({ text: value, source, ...(at ? { at } : {}) });
   };
-  const own = entries.filter((raw): raw is { type: string; message: { role: string; content?: unknown }; timestamp?: string } =>
-    !!raw && typeof raw === "object" && (raw as { type?: string }).type === "message" && (raw as { message?: { role?: string } }).message?.role === "user");
-  for (const entry of [...own].reverse()) add(userText(entry.message), "this session", entry.timestamp ? Date.parse(entry.timestamp) : undefined);
+  for (let index = entries.length - 1; index >= 0; index--) {
+    const raw = entries[index];
+    if (!raw || typeof raw !== "object") continue;
+    const entry = raw as { type?: string; message?: { role?: string; content?: unknown }; timestamp?: string };
+    if (entry.type !== "message" || entry.message?.role !== "user") continue;
+    add(userText(entry.message), "this session", entry.timestamp ? Date.parse(entry.timestamp) : undefined);
+  }
   for (const session of earlier) if (session.firstMessage) add(session.firstMessage, "earlier session", session.modified?.getTime());
   return result;
 }
@@ -36,9 +53,9 @@ export async function openPromptSearch(ctx: ExtensionContext, prompts: readonly
     let query = "";
     let selected = 0;
     let first = 0;
-    let visible: PastPrompt[] = [...prompts];
+    let visible: PastPrompt[] = prompts.slice();
     const rows = 10;
-    const filter = () => { visible = query ? fuzzyFilter([...prompts], query, (item) => item.text) : [...prompts]; selected = 0; first = 0; };
+    const filter = () => { visible = query ? fuzzyFilter(prompts, query, (item) => item.text) : prompts.slice(); selected = 0; first = 0; };
     return {
       invalidate() {},
       handleInput(data: string) {

package/src/quota.ts

@@ -20,17 +20,27 @@ function parseQuota(value: unknown): Quota | undefined {
   return fiveHour || week ? { ...(fiveHour ? { fiveHour } : {}), ...(week ? { week } : {}) } : undefined;
 }
 
+const publishedCache = new Map<string, { raw: string; expiresAt?: number; value?: Quota }>();
+
 /** Public statuses are authoritative only when valid and fresh. No arbitrary status prose is parsed. */
 export function publishedQuota(statuses: ReadonlyMap<string, string>, provider: string, now: number): Quota | undefined {
   const raw = statuses.get(QUOTA_PREFIX + provider);
   if (typeof raw !== "string" || raw.length > 2048) return undefined;
+  const cached = publishedCache.get(provider);
+  if (cached?.raw === raw) {
+    const { expiresAt, value } = cached;
+    return value && expiresAt != null && expiresAt > now && expiresAt <= now + QUOTA_TTL_MS ? value : undefined;
+  }
   try {
     const data: unknown = JSON.parse(raw);
-    if (!data || typeof data !== "object") return undefined;
+    if (!data || typeof data !== "object") { publishedCache.set(provider, { raw }); return undefined; }
     const obj = data as Record<string, unknown>;
-    if (typeof obj.expiresAt !== "number" || obj.expiresAt <= now || obj.expiresAt > now + QUOTA_TTL_MS) return undefined;
-    return parseQuota(obj);
-  } catch { return undefined; }
+    const expiresAt = obj.expiresAt;
+    const value = parseQuota(obj);
+    if (typeof expiresAt !== "number" || !Number.isFinite(expiresAt) || !value) { publishedCache.set(provider, { raw }); return undefined; }
+    publishedCache.set(provider, { raw, expiresAt, value });
+    return expiresAt > now && expiresAt <= now + QUOTA_TTL_MS ? value : undefined;
+  } catch { publishedCache.set(provider, { raw }); return undefined; }
 }
 
 function codexAccountId(token: string): string | undefined {

package/src/session-branch.ts

@@ -0,0 +1,24 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+type SessionManagerLike = ExtensionContext["sessionManager"] & { getLeafId?: () => string | null | undefined };
+const cache = new WeakMap<object, { leaf: string; branch: readonly unknown[] }>();
+
+/**
+ * Pi's getBranch() walks leaf → root and reverses a new array every call. Reuse that projection
+ * across pi-jar features while the leaf id is unchanged; a new session entry naturally changes
+ * the leaf and invalidates the cache.
+ */
+export function sessionBranch(ctx: Pick<ExtensionContext, "sessionManager">): readonly unknown[] {
+  const manager = ctx.sessionManager as SessionManagerLike;
+  const leaf = manager.getLeafId?.();
+  if (!leaf) return manager.getBranch();
+  const hit = cache.get(manager as object);
+  if (hit?.leaf === leaf) return hit.branch;
+  const branch = manager.getBranch();
+  cache.set(manager as object, { leaf, branch });
+  return branch;
+}
+
+export function clearSessionBranchCache(ctx: Pick<ExtensionContext, "sessionManager">): void {
+  cache.delete(ctx.sessionManager as object);
+}

package/src/session-gallery.ts

@@ -5,8 +5,8 @@ import { GOAL_ENTRY, GoalStore } from "./goals.ts";
 import { cleanText } from "./status.ts";
 
 export const RECENT_SESSIONS = 3;
-/** Larger session files are listed without goal/plan details. */
-const MAX_SCAN_BYTES = 8 * 1024 * 1024;
+/** Welcome metadata is decorative; never parse multi-megabyte old transcripts for it. */
+export const MAX_SCAN_BYTES = 512 * 1024;
 
 export interface RecentSession { path: string; title: string; modified: Date; messages: number; goal?: string; plan?: string }
 

package/src/session-ui.ts

@@ -14,18 +14,28 @@ export function filterSessions(sessions: readonly SessionInfo[], query: string):
 
 export async function pickSession(ctx: ExtensionContext, sessions: readonly SessionInfo[], initial = ""): Promise<string | undefined> {
   if (!ctx.hasUI || ctx.mode !== "tui") return undefined;
+  const indexed = sessions.map((session) => ({
+    session,
+    haystack: `${session.name ?? ""} ${sessionDisplayName(session.name, session.id)} ${session.firstMessage}`.toLowerCase()
+  }));
+  const search = (query: string): SessionInfo[] => {
+    const terms = query.trim().toLowerCase().split(/\s+/).filter(Boolean);
+    if (!terms.length) return sessions.slice();
+    const rows: SessionInfo[] = [];
+    for (const item of indexed) if (terms.every((term) => item.haystack.includes(term))) rows.push(item.session);
+    return rows;
+  };
   return ctx.ui.custom<string | undefined>((tui, theme, _keys, done) => {
     let query = initial.slice(0, 100);
     let selected = 0;
     let first = 0;
     let width = 80;
+    let rows = search(query);
     const pageSize = () => Math.max(2, Math.min(10, Math.floor(((process.stdout.rows ?? 24) - 7) / 2)));
-    const matches = () => filterSessions(sessions, query);
-    const refresh = () => { selected = 0; first = 0; tui.requestRender(); };
+    const refresh = () => { rows = search(query); selected = 0; first = 0; tui.requestRender(); };
     return {
       invalidate() {},
       handleInput(data: string) {
-        const rows = matches();
         if (matchesKey(data, Key.escape)) return done(undefined);
         if (matchesKey(data, Key.enter)) return done(rows[selected]?.path);
         if (matchesKey(data, Key.up)) selected = Math.max(0, selected - 1);
@@ -39,13 +49,13 @@ export async function pickSession(ctx: ExtensionContext, sessions: readonly Sess
       },
       handleMouse(event: TuiMouseEvent) {
         if (event.type === "wheel" && event.wheelDelta) {
-          selected = Math.max(0, Math.min(matches().length - 1, selected + Math.sign(event.wheelDelta)));
+          selected = Math.max(0, Math.min(rows.length - 1, selected + Math.sign(event.wheelDelta)));
           first = Math.max(0, Math.min(selected, first), selected - pageSize() + 1);
           tui.requestRender(); return { handled: true };
         }
         if (event.type !== "click" || event.button !== "left" || event.x >= width) return;
         const index = first + Math.floor((event.y - 2) / 2);
-        const row = matches()[index];
+        const row = rows[index];
         if (event.y >= 2 && event.y < 2 + 2 * pageSize() && row) {
           selected = index; done(row.path); return { handled: true };
         }
@@ -53,7 +63,6 @@ export async function pickSession(ctx: ExtensionContext, sessions: readonly Sess
       render(available: number): string[] {
         width = Math.max(0, available);
         const fit = (line: string) => truncateToWidth(line, width);
-        const rows = matches();
         selected = Math.max(0, Math.min(selected, rows.length - 1));
         const lines = [
           fit(theme.fg("accent", `╭─ SESSIONS · ${rows.length}/${sessions.length} ─`)),