pi-jar 0.1.1 → 0.1.3

package/src/footer.ts

@@ -3,6 +3,7 @@ import { sep } from "node:path";
 import { sliceByColumn, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import { DEFAULT_FOOTER_SETTINGS, type FooterSettings } from "./footer-settings.ts";
 import { roleFrame } from "./animations.ts";
+import { icon, type IconKey, withIcon } from "./icons.ts";
 import type { RoleStatus } from "./roles.ts";
 import { ACTIVE_STATES, cleanText, type JarStatus } from "./status.ts";
 import type { Quota } from "./quota.ts";
@@ -18,8 +19,10 @@ export interface FooterView extends JarStatus {
   settings?: FooterSettings;
   context: string;
   goal?: string;
-  /** pi-jar's own short indicators (changes to review, running shells), shown before extras. */
+  /** pi-jar's own short indicators (changes to review), shown before extras. */
   chips?: readonly string[];
+  /** Live subagents and background shells, one clickable row each. */
+  activity?: readonly FooterActivity[];
   memory?: string;
   cost?: string;
   quota?: Quota;
@@ -30,6 +33,49 @@ export interface FooterView extends JarStatus {
   motionBudget?: number;
 }
 
+export type ActivityState = "queued" | "running" | "done" | "failed" | "stopped";
+export interface FooterActivity {
+  kind: "subagent" | "shell";
+  id: string;
+  name: string;
+  state: ActivityState;
+  /** What it is doing now: the current tool, or the shell command. */
+  detail?: string;
+  /** Right-aligned counters, e.g. `3 tools · 12s`. */
+  stats?: string;
+}
+
+/** A clickable footer region, in the footer component's local cells. */
+export type FooterTarget = { kind: "subagent" | "shell"; id: string } | { kind: "activity" } | { kind: "session" };
+export interface FooterHit { y: number; x0: number; x1: number; target: FooterTarget }
+
+const MAX_ACTIVITY_ROWS = 3;
+const THINKING_ICONS: Record<string, IconKey> = {
+  minimal: "thinkingMinimal", low: "thinkingLow", medium: "thinkingMedium", high: "thinkingHigh", xhigh: "thinkingXhigh", max: "thinkingMax"
+};
+
+/** `ctx 58%` → `◫ 58%`: the icon replaces the word, and ascii keeps the word. */
+const metric = (key: IconKey, word: string, text: string) => withIcon(key, text.startsWith(word + " ") ? text.slice(word.length + 1) : text);
+
+function activityGlyph(state: ActivityState): { glyph: string; color: Color } {
+  if (state === "running") return { glyph: icon("running"), color: "accent" };
+  if (state === "queued") return { glyph: icon("pending"), color: "dim" };
+  if (state === "done") return { glyph: icon("success"), color: "success" };
+  if (state === "failed") return { glyph: icon("error"), color: "error" };
+  return { glyph: icon("stopped"), color: "dim" };
+}
+
+function activityRow(item: FooterActivity, width: number, theme: FooterTheme): string {
+  const { glyph, color } = activityGlyph(item.state);
+  const head = theme.fg(color, glyph) + " " + theme.fg(item.state === "running" ? "accent" : "muted",
+    withIcon(item.kind === "subagent" ? "agent" : "shell", cleanText(item.name, 28)));
+  const stats = item.stats ? theme.fg("dim", cleanText(item.stats, 40)) : "";
+  const room = width - visibleWidth(head) - visibleWidth(stats) - 4;
+  const detail = item.detail && room >= 6 ? "  " + theme.fg("dim", truncateToWidth(cleanText(item.detail, 200), room, "…")) : "";
+  const gap = " ".repeat(Math.max(1, width - visibleWidth(head) - visibleWidth(detail) - visibleWidth(stats)));
+  return truncateToWidth(head + detail + (stats ? gap + stats : ""), width);
+}
+
 function fitCwd(cwd: string, width: number): string {
   if (visibleWidth(cwd) <= width) return cwd;
   return "…" + sliceByColumn(cwd, visibleWidth(cwd) - width + 1, width - 1);
@@ -45,33 +91,50 @@ function roleColor(role: RoleStatus): Color {
 
 /** Every line is bounded in terminal cells; critical role failure takes precedence. */
 export function renderFooter(view: FooterView, width: number, theme: FooterTheme): string[] {
+  return renderFooterLayout(view, width, theme).lines;
+}
+
+/** Footer lines plus the clickable regions (activity rows, the session name) they contain. */
+export function renderFooterLayout(view: FooterView, width: number, theme: FooterTheme): { lines: string[]; hits: FooterHit[] } {
+  const hits: FooterHit[] = [];
+  const lines = footerLines(view, width, theme, hits);
+  return { lines, hits };
+}
+
+function footerLines(view: FooterView, width: number, theme: FooterTheme, hits: FooterHit[]): string[] {
   if (width <= 0) return [];
   const show = view.settings ?? DEFAULT_FOOTER_SETTINGS;
-  if (!view.goal && !Object.entries(show).some(([field, enabled]) => enabled && (field !== "memory" || !!view.memory))) return [];
+  const activity = view.activity ?? [];
+  if (!view.goal && !activity.length && !Object.entries(show).some(([field, enabled]) => enabled && (field !== "memory" || !!view.memory))) return [];
   // Keep tiny terminals unframed so context and urgent role status stay readable.
   const framed = width >= 32;
   const contentWidth = framed ? width - 4 : width;
+  // Local cell offsets of content inside the frame, for click targets.
+  const offsetX = framed ? 2 : 0;
+  const offsetY = framed ? 1 : 0;
   const roles = show.roles ? [...view.roles].sort((a, b) => Number(b.state === "failed") - Number(a.state === "failed")) : [];
   const primary = roles.find((role) => role.state === "failed") ?? roles.find((role) => ACTIVE_STATES.has(role.state));
   const model = cleanText(view.model, 24) || "no-model";
-  const context = cleanText(view.context, 12) || "ctx ?";
+  const context = metric("context", "ctx", cleanText(view.context, 12) || "ctx ?");
   const goal = view.goal ? cleanText(view.goal, 240) : "";
   const quota = view.quota;
-  const windows = [quota?.fiveHour && `5h ${Math.round(quota.fiveHour.used)}%`, quota?.week && `week ${Math.round(quota.week.used)}%`].filter((value): value is string => !!value);
-  const cost = view.cost ? cleanText(view.cost, 20) : undefined;
+  const windowList = [quota?.fiveHour && `5h ${Math.round(quota.fiveHour.used)}%`, quota?.week && `week ${Math.round(quota.week.used)}%`].filter((value): value is string => !!value);
+  const windows = windowList.map((value, index) => index ? value : withIcon("quota", value));
+  const cost = view.cost ? metric("cost", "cost", cleanText(view.cost, 20)) : undefined;
+  const memory = view.memory ? metric("memory", "ram", view.memory) : undefined;
   const prefix = view.demo ? theme.fg("warning", "DEMO") : "";
   const effortColors = {
     off: "thinkingOff", minimal: "thinkingMinimal", low: "thinkingLow", medium: "thinkingMedium",
     high: "thinkingHigh", xhigh: "thinkingXhigh", max: "thinkingMax"
   } as const;
-  const effort = show.effort && view.effort ? theme.fg(effortColors[view.effort], view.effort) : "";
+  const effort = show.effort && view.effort ? theme.fg(effortColors[view.effort], THINKING_ICONS[view.effort] ? withIcon(THINKING_ICONS[view.effort]!, view.effort) : view.effort) : "";
   const firstRole = primary ? `${primary.label} ${roleFrame(primary.state, view.frame, view.animations)}` : undefined;
   const attention = firstRole ?? (show.extras ? view.extras[0] : undefined);
   // At narrow widths reserve the right-hand slot for critical/active status, then context.
-  const modelLabel = show.model ? theme.fg("muted", model) : "";
+  const modelLabel = show.model ? theme.fg("muted", withIcon("model", model)) : "";
   const left = [prefix, modelLabel, effort].filter(Boolean).join(theme.fg("dim", " · "));
   // Context is never dropped; optional metrics move to a second line on medium widths.
-  const metrics = [...(show.context ? [context] : []), ...(show.memory && contentWidth >= 90 && view.memory ? [view.memory] : []), ...(show.cost && contentWidth >= 52 && cost ? [cost] : []), ...(show.quota && contentWidth >= 90 ? windows : [])];
+  const metrics = [...(show.context ? [context] : []), ...(show.memory && contentWidth >= 90 && memory ? [memory] : []), ...(show.cost && contentWidth >= 52 && cost ? [cost] : []), ...(show.quota && contentWidth >= 90 ? windows : [])];
   let right = theme.fg("dim", metrics.join("  ·  "));
   if (contentWidth < 52 && attention && contentWidth >= 26) {
     const room = Math.max(0, contentWidth - Math.min(visibleWidth(left), 12) - visibleWidth(right) - 4);
@@ -87,18 +150,24 @@ export function renderFooter(view: FooterView, width: number, theme: FooterTheme
     if (room >= 3 && beforeEffort) return truncateToWidth(beforeEffort, room) + theme.fg("dim", " · ") + effort;
     return truncateToWidth(beforeEffort || effort, availableLeft);
   })();
-  const name = show.sessionName && view.sessionName ? cleanText(view.sessionName, 128) : "";
+  const name = show.sessionName ? cleanText(view.sessionName || "sessions", 128) : "";
   const rawCwd = show.cwd && view.cwd ? cleanText(view.cwd, 256) : "";
   const home = homedir();
   const cwd = home && rawCwd.startsWith(home + sep) ? `~${rawCwd.slice(home.length)}` : rawCwd;
   let namedLeft = fittedLeft;
   let space = availableLeft - visibleWidth(namedLeft);
-  if (cwd && space >= 7) {
-    const budget = name ? Math.min(24, Math.max(4, Math.floor((space - 6) / 2))) : Math.min(32, space - 3);
-    namedLeft += theme.fg("dim", " · ") + theme.fg("muted", fitCwd(cwd, budget));
+  const folder = icon("folder") ? icon("folder") + " " : "";
+  if (cwd && space >= 7 + folder.length) {
+    const budget = name ? Math.min(24, Math.max(4, Math.floor((space - 6) / 2))) : Math.min(32, space - 3 - folder.length);
+    namedLeft += theme.fg("dim", " · ") + theme.fg("muted", folder + fitCwd(cwd, budget));
     space = availableLeft - visibleWidth(namedLeft);
   }
-  if (name && space >= 7) namedLeft += theme.fg("dim", " · ") + theme.fg("muted", truncateToWidth(name, space - 3, "…"));
+  if (name && space >= 7) {
+    const start = visibleWidth(namedLeft) + 3;
+    const label = truncateToWidth(withIcon("session", name), space - 3, "…");
+    namedLeft += theme.fg("dim", " · ") + theme.fg("muted", label);
+    hits.push({ y: offsetY, x0: offsetX + start, x1: offsetX + start + visibleWidth(label), target: { kind: "session" } });
+  }
   const gap = " ".repeat(Math.max(1, contentWidth - visibleWidth(namedLeft) - visibleWidth(right)));
   const lines = [truncateToWidth(namedLeft + gap + right, contentWidth)];
   if (goal) {
@@ -107,8 +176,16 @@ export function renderFooter(view: FooterView, width: number, theme: FooterTheme
     lines.push(truncateToWidth(goalPrefix + theme.fg("muted", truncateToWidth(goal, room, "…")), contentWidth));
   }
   if (contentWidth < 52) {
-    const small = [...(show.memory && view.memory ? [view.memory] : []), ...(show.quota ? windows : [])];
+    const small = [...(show.memory && memory ? [memory] : []), ...(show.quota ? windows : [])];
     if (small.length && contentWidth >= 26) lines.push(truncateToWidth(theme.fg("dim", small.join("  ·  ")), contentWidth));
+    // Too narrow for rows: one clickable count of live work.
+    const agents = activity.filter((item) => item.kind === "subagent" && (item.state === "running" || item.state === "queued")).length;
+    const shells = activity.filter((item) => item.kind === "shell" && item.state === "running").length;
+    const counts = [agents ? withIcon("subagents", `${agents}`) : "", shells ? withIcon("shell", `${shells}`) : ""].filter(Boolean).join("  ");
+    if (counts) {
+      hits.push({ y: offsetY + lines.length, x0: offsetX, x1: offsetX + contentWidth, target: { kind: "activity" } });
+      lines.push(truncateToWidth(theme.fg("accent", counts), contentWidth));
+    }
     return framed ? frameFooter(lines, width, view, theme) : lines;
   }
 
@@ -123,19 +200,29 @@ export function renderFooter(view: FooterView, width: number, theme: FooterTheme
   const remaining = Math.max(0, view.extras.length - (contentWidth >= 100 ? 2 : 1));
   const extras = show.extras ? view.extras.slice(0, contentWidth >= 100 ? 2 : 1).map((status) => theme.fg("muted", status)) : [];
   if (show.extras && remaining) extras.push(theme.fg("dim", `+${remaining}`));
-  if (show.branch && contentWidth >= 52 && view.branch) extras.push(theme.fg("dim", `git ${cleanText(view.branch, 28)}`));
+  if (show.branch && contentWidth >= 52 && view.branch) extras.push(theme.fg("dim", withIcon("branch", cleanText(view.branch, 28))));
   const chips = (view.chips ?? []).map((chip) => theme.fg("warning", cleanText(chip, 32)));
   const joined = [...segments, ...chips, ...extras].join(theme.fg("dim", "  ·  "));
   if (joined) lines.push(truncateToWidth(joined, contentWidth));
-  if (contentWidth < 90 && ((show.quota && windows.length) || (show.memory && view.memory))) {
-    const summary = [...(show.memory && view.memory ? [view.memory] : []), ...(show.quota ? windows : [])].join("  ·  ");
+  if (contentWidth < 90 && ((show.quota && windows.length) || (show.memory && memory))) {
+    const summary = [...(show.memory && memory ? [memory] : []), ...(show.quota ? windows : [])].join("  ·  ");
     if (summary) lines.push(truncateToWidth(theme.fg("dim", summary), contentWidth));
   }
+  const shown = activity.length > MAX_ACTIVITY_ROWS ? activity.slice(0, MAX_ACTIVITY_ROWS - 1) : activity;
+  for (const item of shown) {
+    hits.push({ y: offsetY + lines.length, x0: offsetX, x1: offsetX + contentWidth, target: { kind: item.kind, id: item.id } });
+    lines.push(activityRow(item, contentWidth, theme));
+  }
+  if (shown.length < activity.length) {
+    hits.push({ y: offsetY + lines.length, x0: offsetX, x1: offsetX + contentWidth, target: { kind: "activity" } });
+    lines.push(truncateToWidth(theme.fg("dim", `  +${activity.length - shown.length} more · ctrl+alt+a to manage`), contentWidth));
+  }
   return framed ? frameFooter(lines, width, view, theme) : lines;
 }
 
 function frameFooter(lines: string[], width: number, view: FooterView, theme: FooterTheme): string[] {
-  const active = (view.settings?.roles ?? true) && view.roles.some((role) => ACTIVE_STATES.has(role.state));
+  const active = ((view.settings?.roles ?? true) && view.roles.some((role) => ACTIVE_STATES.has(role.state)))
+    || !!view.activity?.some((item) => item.state === "running");
   const pulse = active && view.animations ? ["◇", "◈", "◆", "◈"][view.frame % 4] : "◇";
   const top = theme.fg("dim", "╭─") + theme.fg(active ? "accent" : "dim", pulse)
     + theme.fg("dim", "─".repeat(width - 4) + "╮");

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

@@ -0,0 +1,57 @@
+/**
+ * Glyph sets for pi-jar chrome, modelled on omp's symbol presets:
+ * - `unicode`: symbols every monospace font ships (default);
+ * - `nerd`: Nerd Font icons (install a Nerd Font, e.g. via `brew install --cask font-jetbrains-mono-nerd-font`);
+ * - `ascii`: no decorative glyphs; key hints spelled out.
+ * Decorative keys may map to "" in `ascii`; always render through `withIcon`.
+ */
+export const ICON_SETS = ["unicode", "nerd", "ascii"] as const;
+export type IconSet = (typeof ICON_SETS)[number];
+
+export type IconKey =
+  | "pi" | "model" | "folder" | "branch" | "context" | "memory" | "cost" | "quota" | "session"
+  | "subagents" | "agent" | "shell" | "changes" | "goal" | "plan" | "tasks" | "time" | "tools" | "roles"
+  | "esc" | "enter" | "tab" | "shiftEnter"
+  | "success" | "error" | "running" | "pending" | "stopped" | "warning"
+  | "thinkingMinimal" | "thinkingLow" | "thinkingMedium" | "thinkingHigh" | "thinkingXhigh" | "thinkingMax";
+
+const UNICODE: Record<IconKey, string> = {
+  pi: "π", model: "⬢", folder: "⌂", branch: "⎇", context: "◫", memory: "▤", cost: "", quota: "◔", session: "◈",
+  subagents: "⧉", agent: "◉", shell: "⚙", changes: "±", goal: "◎", plan: "◆", tasks: "☰", time: "◷", tools: "⚒", roles: "⇄",
+  esc: "⎋", enter: "⏎", tab: "⇥", shiftEnter: "⇧⏎",
+  success: "✔", error: "✖", running: "●", pending: "○", stopped: "■", warning: "⚠",
+  thinkingMinimal: "○", thinkingLow: "◔", thinkingMedium: "◑", thinkingHigh: "◒", thinkingXhigh: "◕", thinkingMax: "◉"
+};
+
+// Code points follow omp's nerd preset (Font Awesome / Codicons / Material Design ranges).
+const NERD: Record<IconKey, string> = {
+  pi: "\u{f0d57}", model: "\uec19", folder: "\uf115", branch: "\uf126", context: "\ue70f", memory: "\u{f035b}",
+  cost: "\uf0d6", quota: "\uf0e4", session: "\u{f02da}",
+  subagents: "\uf0c0", agent: "\uf007", shell: "\uf120", changes: "\uf044", goal: "\uf140", plan: "\uf2d2",
+  tasks: "\uf0ae", time: "\uf017", tools: "\uf0ad", roles: "\u{f04e1}",
+  esc: "\u{f12b7}", enter: "\u{f0311}", tab: "\u{f0312}", shiftEnter: "\u{f0636}\u{f0311}",
+  success: "\uf00c", error: "\uf00d", running: "\uf111", pending: "\uf10c", stopped: "\uf04d", warning: "\uf071",
+  thinkingMinimal: "\u{f0a9e}", thinkingLow: "\u{f0a9f}", thinkingMedium: "\u{f0aa1}", thinkingHigh: "\u{f0aa3}",
+  thinkingXhigh: "\u{f0aa5}", thinkingMax: "\uf06d"
+};
+
+const ASCII: Record<IconKey, string> = {
+  pi: "", model: "", folder: "", branch: "git", context: "ctx", memory: "ram", cost: "cost", quota: "quota", session: "",
+  subagents: "", agent: "", shell: "$", changes: "+/-", goal: "goal", plan: "plan", tasks: "", time: "", tools: "", roles: "",
+  esc: "esc", enter: "enter", tab: "tab", shiftEnter: "shift+enter",
+  success: "ok", error: "x", running: "*", pending: "-", stopped: "#", warning: "!",
+  thinkingMinimal: "", thinkingLow: "", thinkingMedium: "", thinkingHigh: "", thinkingXhigh: "", thinkingMax: ""
+};
+
+const SETS: Record<IconSet, Record<IconKey, string>> = { unicode: UNICODE, nerd: NERD, ascii: ASCII };
+let active: IconSet = "unicode";
+
+/** Process-wide: renderers read the active set on every paint, so a settings change applies on the next frame. */
+export function setIconSet(set: IconSet): void { active = set; }
+export function iconSet(): IconSet { return active; }
+export function icon(key: IconKey): string { return SETS[active][key]; }
+/** `glyph text`, or just `text` when the active set has no glyph for `key`. */
+export function withIcon(key: IconKey, text: string): string {
+  const glyph = SETS[active][key];
+  return glyph ? (text ? glyph + " " + text : glyph) : text;
+}

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";
@@ -74,6 +75,7 @@ export class PlanMode {
   private reminders = 0;
   private reviewing = false;
   private compacting = false;
+  private contextDirty = true;
   private compactGeneration = 0;
   private executionRestore: (() => Promise<void>) | undefined;
   private executionRunning = false;
@@ -135,6 +137,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 +152,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 +297,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 +314,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 +417,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 +460,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 +480,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); });
   }
 }