pi-jar 0.1.0 → 0.1.2

package/src/composer.ts

@@ -11,6 +11,7 @@ type MouseEvent = Parameters<NonNullable<EditorComponent["handleMouse"]>>[0];
 const PHASE_MOODS: Record<WorkingPhase, readonly MascotMood[]> = {
   idle: ["idle"], generating: ["happy", "thinking"], tool: ["tool"], waiting: ["waiting"]
 };
+export const COMPOSER_ACTIVE_INTERVAL_MS = 600;
 /** Plain one-line face for a phase; every phase has the same width. */
 export function composerIcon(phase: WorkingPhase, frame = 0): string {
   const moods = PHASE_MOODS[phase];
@@ -256,7 +257,7 @@ export class ComposerStyle {
   private owner?: EditorFactory;
   private previous?: EditorFactory;
   private tui?: TUI;
-  private timer?: ReturnType<typeof setInterval>;
+  private timer?: ReturnType<typeof setTimeout>;
   private phase: WorkingPhase = "idle";
   private frame = 0;
   private animations = true;
@@ -279,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,
@@ -291,7 +293,7 @@ export class ComposerStyle {
       return text;
     },
     typed: () => this.suggestions?.clear(),
-    poke: () => { this.mascot.flash("poke", 1500); this.tui?.requestRender(); },
+    poke: () => { this.mascot.flash("poke", 1500); this.restartTimer(); this.tui?.requestRender(); },
     dim: (text) => this.colors?.fg("dim", text) ?? `\x1b[2m${text}\x1b[22m`,
     attachments: (text) => {
       if (!/\.(png|jpe?g|gif|webp)\b/i.test(text)) return undefined;
@@ -318,36 +320,49 @@ export class ComposerStyle {
   /** Short-lived expression, e.g. on errors or a completed goal. */
   flash(mood: "error" | "complete" | "poke", ms = 3000): void {
     this.mascot.flash(mood, ms);
+    this.restartTimer();
     if (this.enabled) this.tui?.requestRender();
   }
 
   setActivity(phase: WorkingPhase, animations: boolean): void {
     const changed = this.phase !== phase || this.animations !== animations;
     this.mascot.setPhase(phase);
-    if (!changed && (this.timer || !this.enabled || !animations)) return;
+    if (!changed) return;
     this.phase = phase;
     this.animations = animations;
-    if (changed) this.frame = 0;
+    this.frame = 0;
     this.restartTimer();
-    if (changed && this.enabled) this.tui?.requestRender();
+    if (this.enabled) this.tui?.requestRender();
   }
 
-  /** One unref'd timer drives flicker, blinks and sleepiness; it renders only when the sprite changes. */
+  /**
+   * 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();
-    if (!this.enabled || !this.animations) return;
-    const active = this.phase === "generating" || this.phase === "tool";
-    if (!active && !this.mascotOn) return;
-    this.timer = setInterval(() => {
+    if (!this.enabled || !this.animations || !this.mascotOn) return;
+    this.lastKey = this.mascot.key(Date.now(), this.frame);
+    this.scheduleTimer();
+  }
+  private scheduleTimer(): void {
+    if (!this.enabled || !this.animations || !this.mascotOn || this.timer) return;
+    const delay = this.mascot.nextTransitionDelay(Date.now());
+    if (delay === undefined) return;
+    this.timer = setTimeout(() => {
+      this.timer = undefined;
       this.frame++;
-      const key = this.mascotOn ? this.mascot.key(Date.now(), this.frame) : String(this.frame);
-      if (key === this.lastKey) return;
-      this.lastKey = key;
-      this.tui?.requestRender();
-    }, 240);
+      const key = this.mascot.key(Date.now(), this.frame);
+      if (key !== this.lastKey) {
+        this.lastKey = key;
+        this.tui?.requestRender();
+      }
+      this.scheduleTimer();
+    }, delay);
     this.timer.unref?.();
   }
-  private stopTimer(): void { if (this.timer) clearInterval(this.timer); this.timer = undefined; }
+  private stopTimer(): void { if (this.timer) clearTimeout(this.timer); this.timer = undefined; }
   refreshSession(ctx: ExtensionContext): void {
     const manager = ctx.sessionManager as { getSessionId?: () => string; getSessionName?: () => string | undefined } | undefined;
     const next = sessionDisplayName(manager?.getSessionName?.(), manager?.getSessionId?.());

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

@@ -18,7 +18,7 @@ export const safeLine = (text: string) => text.slice(0, 4000).replace(/\t/g, "
 
 /** Styled diff rows for one file, with a gutter of old/new line numbers. */
 export function renderDiff(change: FileChange, width: number, fg: (color: string, text: string) => string): string[] {
-  const ops = lineDiff(change.before, change.after);
+  const ops = change.diff === null ? undefined : (change.diff ?? lineDiff(change.before, change.after));
   if (!ops) return [fg("warning", `Too large for an inline diff: +${change.added} −${change.removed} lines.`)];
   const rows: DiffRow[] = diffRows(ops);
   if (!rows.length) return [fg("dim", "No textual changes.")];
@@ -142,12 +142,34 @@ export async function openDiffView(ctx: ExtensionContext, tracker: ChangeTracker
 
 /** Track edit/write targets before they run, and expose `/diff` plus ctrl+alt+d. */
 export function registerChangeReview(pi: ExtensionAPI, tracker: () => ChangeTracker | undefined, changed: () => void): void {
+  // Keep the path that belonged to each in-flight edit/write so tool completion dirties only
+  // that file. Older Pi builds may omit toolCallId here, hence the small FIFO fallback.
+  const pending = new Map<string, string>();
+  const fallback: string[] = [];
   pi.on("tool_call", (event) => {
     if (event.toolName !== "edit" && event.toolName !== "write") return;
     const path = (event.input as { path?: unknown }).path;
-    if (typeof path === "string" && path.trim()) tracker()?.capture(path);
+    if (typeof path !== "string" || !path.trim() || !tracker()?.capture(path)) return;
+    const id = (event as { toolCallId?: unknown }).toolCallId;
+    if (typeof id === "string" && id) pending.set(id, path);
+    fallback.push(path);
+  });
+  pi.on("tool_result", (event) => {
+    if (event.toolName !== "edit" && event.toolName !== "write") return;
+    const id = (event as { toolCallId?: unknown }).toolCallId;
+    let path: string | undefined;
+    if (typeof id === "string" && id) {
+      path = pending.get(id);
+      pending.delete(id);
+      if (path) {
+        const index = fallback.indexOf(path);
+        if (index >= 0) fallback.splice(index, 1);
+      }
+    }
+    if (!path) path = fallback.shift();
+    const failed = (event as { isError?: unknown }).isError === true;
+    if (path && !failed && tracker()?.markDirty(path)) changed();
   });
-  pi.on("tool_result", (event) => { if (event.toolName === "edit" || event.toolName === "write") changed(); });
   const open = async (ctx: ExtensionContext) => {
     const current = tracker();
     if (!current) return;

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/mascot.ts

@@ -79,6 +79,20 @@ export class Mascot {
     return tips[((frame % tips.length) + tips.length) % tips.length]!;
   }
 
+  /**
+   * Milliseconds until an idle mascot can visibly change again. Active phases are driven by
+   * the composer's low-frequency animation clock; idle uses this deadline instead of polling.
+   */
+  nextTransitionDelay(now = Date.now()): number | undefined {
+    const current = this.mood(now);
+    if (this.flashMood && now < this.flashMood.until) return Math.max(16, this.flashMood.until - now);
+    if (this.phase !== "idle") return undefined;
+    const sleepyAt = this.lastActive + SLEEPY_AFTER_MS;
+    if (now >= sleepyAt) return undefined;
+    const next = current === "blink" ? Math.min(this.nextBlink + BLINK_MS, sleepyAt) : Math.min(this.nextBlink, sleepyAt);
+    return Math.max(16, next - now);
+  }
+
   /** Visual identity for change detection (avoids needless renders). */
   key(now = Date.now(), frame = 0): string { return this.mood(now) + ":" + this.tip(now, frame); }
 }

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) {