pi-jar 0.1.2 → 0.1.4

package/src/dialogs.ts

@@ -1,6 +1,6 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Input, Key, matchesKey, truncateToWidth, wrapTextWithAnsi, type TuiMouseEvent } from "@earendil-works/pi-tui";
-import { todoMark, type Todo } from "./tasks.ts";
+import { todoMark, todoProgress, todoTotals, type Todo } from "./tasks.ts";
 import { cleanText } from "./status.ts";
 
 const fit = (line: string, width: number) => truncateToWidth(line, Math.max(0, width));
@@ -111,13 +111,17 @@ export async function todoView(ctx: ExtensionContext, todos: () => Todo[], filte
       render(width: number): string[] {
         const items = filtered();
         selected = Math.min(selected, Math.max(0, items.length - 1));
-        const count = todos().filter((item) => !item.done).length;
+        const all = todos();
+        const totals = todoTotals(all);
         const start = Math.max(0, selected - 11);
         firstVisible = start;
         return [
-          fit(theme.fg("accent", `╭─ pi-jar to-do · ${count} open · ${filter.value} ─`), width),
-          ...(items.length ? items.slice(start, start + 12).map((item, index) =>
-            fit(theme.fg(start + index === selected ? "accent" : item.done ? "dim" : item.status === "in_progress" ? "warning" : "muted", `${start + index === selected ? "❯" : " "} ${todoMark(item)} ${item.title}`), width))
+          fit(theme.fg("accent", `╭─ pi-jar to-do · ${totals.total - totals.done} open · ${filter.value} ─`), width),
+          ...(items.length ? items.slice(start, start + 12).map((item, index) => {
+            const progress = todoProgress(all, item.id);
+            const row = `${start + index === selected ? "❯" : " "} ${item.parentId ? "  " : ""}${todoMark(item)} ${item.title}${progress.total ? ` (${progress.done}/${progress.total})` : ""}`;
+            return fit(theme.fg(start + index === selected ? "accent" : item.done ? "dim" : item.status === "in_progress" ? "warning" : "muted", row), width);
+          })
             : [fit(theme.fg("dim", "  No items in this view"), width)]),
           fit(theme.fg("dim", "╰─ ↑↓: select · Space: check · a: add · e: edit · d: delete · f: filter · Esc: close"), width)
         ];

package/src/diff-view.ts

@@ -1,6 +1,7 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Key, matchesKey, truncateToWidth, type TuiMouseEvent } from "@earendil-works/pi-tui";
 import { diffRows, lineDiff, type ChangeTracker, type DiffRow, type FileChange } from "./changes.ts";
+import { CHILD_BASELINE_ENV, writeChildBaseline } from "./child-baselines.ts";
 import { contentRows, optionList, sidebarWidth, splitFrame } from "./split-view.ts";
 
 const ACTIONS = [
@@ -146,10 +147,21 @@ export function registerChangeReview(pi: ExtensionAPI, tracker: () => ChangeTrac
   // that file. Older Pi builds may omit toolCallId here, hence the small FIFO fallback.
   const pending = new Map<string, string>();
   const fallback: string[] = [];
+  // Subagent side: hand each first-edit baseline to the parent so its /diff covers our edits.
+  const reported = new Set<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)) return;
+    const current = tracker();
+    if (typeof path !== "string" || !path.trim() || !current?.capture(path)) return;
+    const dir = process.env[CHILD_BASELINE_ENV];
+    const abs = current.absolute(path);
+    const before = current.baseline(abs);
+    // A failed write is reported once and not retried: a later retry would share a newer baseline.
+    if (dir && before !== undefined && !reported.has(abs)) {
+      try { writeChildBaseline(dir, abs, before); }
+      catch (error) { reported.add(abs); console.error(`pi-jar: cannot share baseline for ${abs}: ${String(error)}`); }
+    }
     const id = (event as { toolCallId?: unknown }).toolCallId;
     if (typeof id === "string" && id) pending.set(id, path);
     fallback.push(path);

package/src/flame.ts

@@ -46,9 +46,17 @@ function hexRgb(hex: string): [number, number, number] | undefined {
   return [0, 2, 4].map((at) => Number.parseInt(value.slice(at, at + 2), 16)) as [number, number, number];
 }
 
+/** 24-bit foreground prefix per hex color: the flame and Ember repaint the same ramp colors every frame. */
+const foregrounds = new Map<string, string>();
+
 export function rgb(hex: string, text: string): string {
-  const color = hexRgb(hex);
-  return color ? `\x1b[38;2;${color[0]};${color[1]};${color[2]}m${text}\x1b[39m` : text;
+  let prefix = foregrounds.get(hex);
+  if (prefix === undefined) {
+    const color = hexRgb(hex);
+    prefix = color ? `\x1b[38;2;${color[0]};${color[1]};${color[2]}m` : "";
+    if (foregrounds.size < 64) foregrounds.set(hex, prefix);
+  }
+  return prefix ? prefix + text + "\x1b[39m" : text;
 }
 
 function cell(top: number, bottom: number): string {
@@ -59,6 +67,8 @@ function cell(top: number, bottom: number): string {
   if (down) return `\x1b[38;2;${down[0]};${down[1]};${down[2]}m▄\x1b[39m`;
   return " ";
 }
+/** Every truecolor half-block pair, built once instead of parsing two hex colors per cell per frame. */
+const CELLS = Array.from({ length: FLAME_RAMP.length ** 2 }, (_, index) => cell(Math.floor(index / FLAME_RAMP.length), index % FLAME_RAMP.length));
 
 /** Terminals without 24-bit color get shaded blocks in theme colors instead. */
 function shadedCell(top: number, bottom: number, paint: FlamePaint): string {
@@ -217,7 +227,7 @@ export class FlameSim {
     const rows: string[][] = Array.from({ length: this.rows / 2 }, (_, row) => Array.from({ length: this.width }, (_, x) => {
       const top = this.heat[row * 2 * this.width + x]!;
       const bottom = this.heat[(row * 2 + 1) * this.width + x]!;
-      return truecolor ? cell(top, bottom) : shadedCell(top, bottom, paint);
+      return truecolor ? CELLS[top * FLAME_RAMP.length + bottom] ?? cell(top, bottom) : shadedCell(top, bottom, paint);
     }));
     for (const particle of this.particles) {
       const x = Math.round(particle.x);
@@ -234,12 +244,15 @@ export class FlameSim {
   }
 }
 
-let cached: { seed: number; sim: FlameSim } | undefined;
+let cached: { seed: number; sim: FlameSim; frame?: number; rows?: string[] } | undefined;
 
 /** Rendered flame rows for an absolute frame; replays deterministically for a seed. */
 export function flameFrame(frame: number, seed = 1, paint?: FlamePaint, truecolor = supportsTruecolor()): string[] {
   const target = Math.max(0, Math.floor(Number.isFinite(frame) ? frame : 0));
   if (!cached || cached.seed !== seed || cached.sim.frame > target) cached = { seed, sim: new FlameSim(seed) };
   while (cached.sim.frame < target) cached.sim.step();
-  return cached.sim.render(paint, truecolor);
+  if (!truecolor) return cached.sim.render(paint, truecolor);
+  // Truecolor rows never use `paint`, so repaints between flame ticks (typing, streaming) reuse the frame.
+  if (cached.frame !== target || !cached.rows) { cached.rows = cached.sim.render(paint, true); cached.frame = target; }
+  return cached.rows.slice();
 }

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, iconSet, 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,60 @@ 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"
+};
+const EFFORT_COLORS = {
+  off: "thinkingOff", minimal: "thinkingMinimal", low: "thinkingLow", medium: "thinkingMedium",
+  high: "thinkingHigh", xhigh: "thinkingXhigh", max: "thinkingMax"
+} as const;
+/** Every other color the footer paints; one sample of each keys the render cache to the live theme. */
+const FOOTER_COLORS: readonly Color[] = ["accent", "warning", "success", "error", "dim", "muted"];
+
+/** `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 headWidth = visibleWidth(head);
+  const statsWidth = visibleWidth(stats);
+  const room = width - headWidth - statsWidth - 4;
+  const detail = item.detail && room >= 6 ? "  " + theme.fg("dim", truncateToWidth(cleanText(item.detail, 200), room, "…")) : "";
+  const detailWidth = visibleWidth(detail);
+  const gap = Math.max(1, width - headWidth - detailWidth - statsWidth);
+  const row = head + detail + (stats ? " ".repeat(gap) + stats : "");
+  // The parts are already measured; only a head and stats too wide on their own need cutting.
+  return headWidth + detailWidth + (stats ? gap + statsWidth : 0) <= width ? row : truncateToWidth(row, 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 +102,53 @@ 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;
+}
+
+/** Pi repaints the footer on every render (each streamed token) while its inputs change far less often. */
+let lastFooter: { key: string; lines: string[]; hits: FooterHit[] } | undefined;
+
+/** 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 colors = FOOTER_COLORS.map((color) => theme.fg(color, "x")).join("") + (view.effort ? theme.fg(EFFORT_COLORS[view.effort], "x") : "");
+  const key = `${width}\0${iconSet()}\0${homedir()}\0${colors}\0${JSON.stringify(view)}`;
+  if (lastFooter?.key !== key) {
+    const hits: FooterHit[] = [];
+    lastFooter = { key, lines: footerLines(view, width, theme, hits), hits };
+  }
+  return { lines: lastFooter.lines.slice(), hits: lastFooter.hits.slice() };
+}
+
+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(EFFORT_COLORS[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,28 +164,46 @@ 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, "…"));
-  const gap = " ".repeat(Math.max(1, contentWidth - visibleWidth(namedLeft) - visibleWidth(right)));
-  const lines = [truncateToWidth(namedLeft + gap + right, contentWidth)];
+  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 namedWidth = visibleWidth(namedLeft);
+  const rightWidth = visibleWidth(right);
+  const gap = Math.max(1, contentWidth - namedWidth - rightWidth);
+  const first = namedLeft + " ".repeat(gap) + right;
+  const lines = [namedWidth + gap + rightWidth <= contentWidth ? first : truncateToWidth(first, contentWidth)];
   if (goal) {
     const goalPrefix = theme.fg("accent", "◎ goal") + theme.fg("dim", " · ");
-    const room = Math.max(0, contentWidth - visibleWidth(goalPrefix));
-    lines.push(truncateToWidth(goalPrefix + theme.fg("muted", truncateToWidth(goal, room, "…")), contentWidth));
+    const prefixWidth = visibleWidth(goalPrefix);
+    const line = goalPrefix + theme.fg("muted", truncateToWidth(goal, Math.max(0, contentWidth - prefixWidth), "…"));
+    lines.push(prefixWidth <= contentWidth ? line : truncateToWidth(line, 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 +218,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/history-ui.ts

@@ -1,6 +1,7 @@
 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 { createHistorySnapshot, historyChunk, historyPage, safeHistoryText, type HistoryChunk, type HistoryItem } from "./history.ts";
+import { RowCache } from "./row-cache.ts";
 import { sessionBranch } from "./session-branch.ts";
 
 /** Separate, read-only view. Pi's native transcript and session file are never modified. */
@@ -52,7 +53,15 @@ export async function openJarHistory(ctx: ExtensionContext): Promise<void> {
       tui.requestRender();
     };
     input.onEscape = () => { searching = false; input.focused = false; tui.requestRender(); };
-    const chunks = () => selectedItem() ? historyChunk(selectedItem()!, offsets.at(-1)!) : undefined;
+    // Every render (each streamed token while this is open) needs the selected chunk; re-slice only on change.
+    let loaded: { item: HistoryItem; offset: number; chunk: HistoryChunk } | undefined;
+    const chunks = () => {
+      const item = selectedItem();
+      if (!item) return undefined;
+      const offset = offsets.at(-1)!;
+      if (loaded?.item !== item || loaded.offset !== offset) loaded = { item, offset, chunk: historyChunk(item, offset) };
+      return loaded.chunk;
+    };
     const moveChunk = (direction: number) => {
       const chunk = chunks();
       if (direction > 0 && chunk?.more && chunk.nextOffset > offsets.at(-1)!) offsets.push(chunk.nextOffset);
@@ -60,13 +69,10 @@ export async function openJarHistory(ctx: ExtensionContext): Promise<void> {
       detailScroll = 0;
       expanded = true;
     };
-    const fit = (text: string) => truncateToWidth(text, Math.max(0, width));
-    const line = (content: string) => {
-      const inside = Math.max(0, width - 4);
-      const clipped = truncateToWidth(content, inside);
-      return fit(theme.fg("dim", "│ ") + clipped + " ".repeat(Math.max(0, inside - visibleWidth(clipped))) + theme.fg("dim", " │"));
-    };
-    const border = (left: string, middle: string, right: string) => fit(theme.fg("dim", left + middle.repeat(Math.max(0, width - 2)) + right));
+    // Rows are built from exact-width parts: one truncate-and-pad pass per new row, reused while it stays on screen.
+    const framed = new RowCache();
+    const line = (content: string) => framed.get(content, (row) => theme.fg("dim", "│ ") + truncateToWidth(row, Math.max(0, width - 4), "...", true) + theme.fg("dim", " │"));
+    const border = (left: string, middle: string, right: string) => theme.fg("dim", left + middle.repeat(Math.max(0, width - 2)) + right);
     return {
       invalidate() { input.invalidate(); },
       handleInput(data: string) {
@@ -103,11 +109,12 @@ export async function openJarHistory(ctx: ExtensionContext): Promise<void> {
       },
       render(available: number): string[] {
         width = Math.max(8, available);
+        framed.begin(`${width}\0${theme.fg("dim", "│")}`);
         const start = first();
         const items = current.items.slice(start, start + listRows());
         const heading = ` pi-jar · history · ${snapshot.visible.length} turns`;
-        const top = fit(theme.fg("accent", "╭─" + truncateToWidth(heading, Math.max(0, width - 6))
-          + "─".repeat(Math.max(0, width - 4 - visibleWidth(heading))) + "×╮"));
+        const top = theme.fg("accent", "╭─" + truncateToWidth(heading, Math.max(0, width - 6))
+          + "─".repeat(Math.max(0, width - 4 - visibleWidth(heading))) + "×╮");
         const subtitle = ` Active branch · page ${current.page + 1}/${current.totalPages} · snapshot at open`;
         const rows = items.length ? items.map((item, position) => {
           const index = start + position;
@@ -130,7 +137,7 @@ export async function openJarHistory(ctx: ExtensionContext): Promise<void> {
         const help = searching ? line(input.render(Math.max(1, width - 4))[0] ?? "/")
           : line(theme.fg("dim", notice || (width >= 66 ? "↑↓/Pg: move · /: search · n/N: next · e: expand · d/u: detail · [ ]: chunks · p/o: pages · Esc" : "↑↓ move · / search · e expand · p/o pages · Esc")));
         return [top, line(theme.fg("muted", subtitle)), border("├", "─", "┤"), ...rows,
-          border("├", "─", "┤"), line(theme.fg("accent", headingDetail)), ...body, help, border("╰", "─", "╯")].map(fit);
+          border("├", "─", "┤"), line(theme.fg("accent", headingDetail)), ...body, help, border("╰", "─", "╯")];
       }
     };
   }, { overlay: true, overlayOptions: { anchor: "center", width: 92, maxHeight: "80%" } });

package/src/history.ts

@@ -139,8 +139,10 @@ export function historyPage(snapshot: HistorySnapshot, page = 0, size = HISTORY_
   return { items, page: at, totalPages };
 }
 
+export interface HistoryChunk { lines: string[]; more: boolean; nextOffset: number; trailingNewline: boolean }
+
 /** Fetch only the requested 2 KiB / 30-line segment; nextOffset never skips hidden lines. */
-export function historyChunk(item: HistoryItem, offset = 0): { lines: string[]; more: boolean; nextOffset: number; trailingNewline: boolean } {
+export function historyChunk(item: HistoryItem, offset = 0): HistoryChunk {
   const at = Math.max(0, Math.min(200_000_000, Math.floor(offset) || 0));
   const { raw, more } = excerpt(item.entry, HISTORY_CHUNK_SIZE, at);
   // Limit UTF-8 bytes as well as UTF-16 code units (CJK/emoji can exceed 2 KiB).

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/model-roles.ts

@@ -21,7 +21,7 @@ export type RoleScope = "global" | "project";
 export interface RoleAssignment { provider: string; model: string; thinking?: ThinkingLevel }
 export interface ResolvedRole extends RoleAssignment { via: string[] }
 export interface RoleTag { name?: string; color?: string }
-export interface RoleConfig { version: 2; roles: Record<string, string>; cycleOrder?: string[]; tags?: Record<string, RoleTag> }
+export interface RoleConfig { version: 2; roles: Record<string, string>; cycleOrder?: string[]; tags?: Record<string, RoleTag>; fallbacks?: Record<string, string[]> }
 export interface RoleRow {
   role: string; label: string; usedBy?: string; custom: boolean;
   spec?: string; scope?: RoleScope; resolved?: ResolvedRole; error?: string;
@@ -67,6 +67,17 @@ export function parseRoleConfig(raw: unknown): RoleConfig {
     }
     if (spec) config.roles[role] = spec;
   }
+  if (value.fallbacks && typeof value.fallbacks === "object") {
+    const fallbacks: Record<string, string[]> = {};
+    for (const [role, entries] of Object.entries(value.fallbacks)) {
+      if (!isRoleName(role) || !Array.isArray(entries)) continue;
+      fallbacks[role] = [...new Set(entries.flatMap((entry) => {
+        const spec = typeof entry === "string" ? normalizeSpec(entry) : undefined;
+        return spec ? [spec] : [];
+      }))].slice(0, 8);
+    }
+    if (Object.keys(fallbacks).length) config.fallbacks = fallbacks;
+  }
   if (Array.isArray(value.cycleOrder)) {
     const order = value.cycleOrder.filter((item): item is string => typeof item === "string" && isRoleName(item));
     if (order.length) config.cycleOrder = [...new Set(order)];
@@ -143,6 +154,8 @@ export class ModelRoleManager {
   private applying = false;
   /** Bumped whenever the user picks a model or effort themselves. */
   private manualEpoch = 0;
+  /** Last `summary()`, valid while the same (replaced-on-write) configs are loaded. */
+  private summaryMemo: { global: RoleConfig; project: RoleConfig; limit: number; text: string } | undefined;
 
   constructor(pi: ExtensionAPI) {
     this.pi = pi;
@@ -188,12 +201,16 @@ export class ModelRoleManager {
     });
   }
 
-  /** Summary for compact surfaces such as the welcome card. */
+  /** Summary for compact surfaces such as the welcome card, which repaints every frame. */
   summary(limit = 3): string {
+    const memo = this.summaryMemo;
+    if (memo?.global === this.global && memo.project === this.project && memo.limit === limit) return memo.text;
     const rows = this.list().filter((row) => row.resolved || row.spec);
-    if (!rows.length) return "all roles follow the current model";
-    return rows.slice(0, limit).map((row) => row.role + "→" + (row.spec?.startsWith("@") ? row.spec.split(":")[0] : row.resolved?.model ?? "?")).join(" · ")
-      + (rows.length > limit ? ` · +${rows.length - limit}` : "");
+    const text = !rows.length ? "all roles follow the current model"
+      : rows.slice(0, limit).map((row) => row.role + "→" + (row.spec?.startsWith("@") ? row.spec.split(":")[0] : row.resolved?.model ?? "?")).join(" · ")
+        + (rows.length > limit ? ` · +${rows.length - limit}` : "");
+    this.summaryMemo = { global: this.global, project: this.project, limit, text };
+    return text;
   }
 
   private status(ctx: ExtensionContext): void {
@@ -279,6 +296,32 @@ export class ModelRoleManager {
     if (scope === "project") this.project = next; else this.global = next;
   }
 
+  /** Project lists replace global lists; an empty project list disables inherited fallbacks. */
+  fallbackSpecs(role: string): string[] {
+    return [...(this.project.fallbacks?.[role] ?? this.global.fallbacks?.[role] ?? [])];
+  }
+
+  resolveSpec(spec: string): ResolvedRole {
+    const result = resolveRole({ ...this.merged(), __fallback__: spec }, "__fallback__");
+    if (!result || "error" in result) throw new Error(result?.error ?? "Invalid fallback model");
+    return result;
+  }
+
+  updateFallbacks(role: string, specs: string[], scope: RoleScope = "global"): void {
+    if (!isRoleName(role)) throw new Error("Invalid role name: " + role);
+    if (specs.length > 8) throw new Error("At most 8 fallback models are allowed");
+    const normalized = specs.map((spec) => {
+      const target = normalizeSpec(spec);
+      if (!target) throw new Error("Invalid fallback target: " + spec);
+      return target;
+    });
+    if (scope === "project" && !this.cwd) throw new Error("Project roles need a working directory");
+    const target = scope === "project" ? this.project : this.global;
+    const next: RoleConfig = { ...target, fallbacks: { ...target.fallbacks, [role]: [...new Set(normalized)] } };
+    writeConfig(scope === "project" ? projectRoleFile(this.cwd!) : join(getAgentDir(), ROLE_FILE), next);
+    if (scope === "project") this.project = next; else this.global = next;
+  }
+
   register(openUi?: (ctx: ExtensionContext) => Promise<void>): void {
     const manual = (_event: unknown, ctx: ExtensionContext) => {
       if (this.applying) return;
@@ -294,13 +337,25 @@ export class ModelRoleManager {
     });
 
     this.pi.registerCommand("roles", {
-      description: "Configure model roles (default/smol/slow/plan/advisor/task/commit or custom): /roles, /roles set ROLE provider/model[:effort]|@role, /roles <role>",
+      description: "Configure model roles: /roles, /roles set ROLE provider/model[:effort]|@role, /roles fallback ROLE MODEL...|clear, /roles <role>",
       handler: async (args, ctx) => {
         const parts = args.trim().split(/\s+/).filter(Boolean);
         const verb = (parts[0] ?? "").toLowerCase();
         if (!verb || verb === "list") {
           if (!verb && ctx.hasUI && ctx.mode === "tui" && openUi) { await openUi(ctx); return; }
-          ctx.ui.notify(this.list().map(describeRole).join("\n"), "info");
+          ctx.ui.notify(this.list().map((row) => describeRole(row) + (this.fallbackSpecs(row.role).length
+            ? "  · fallbacks: " + this.fallbackSpecs(row.role).join(" → ") : "")).join("\n"), "info");
+          return;
+        }
+        if (verb === "fallback") {
+          const role = parts[1] ?? "";
+          const scope: RoleScope = parts.includes("--project") ? "project" : "global";
+          const targets = parts.slice(2).filter((part) => part !== "--project");
+          if (!isRoleName(role)) { ctx.ui.notify("Usage: /roles fallback ROLE [PROVIDER/MODEL[:effort]|@ROLE ...|clear] [--project]", "error"); return; }
+          if (!targets.length) { ctx.ui.notify(role + " fallbacks: " + (this.fallbackSpecs(role).join(" → ") || "none"), "info"); return; }
+          try { this.updateFallbacks(role, targets.length === 1 && targets[0] === "clear" ? [] : targets, scope); }
+          catch (error) { ctx.ui.notify("Could not save fallbacks: " + (error as Error).message, "error"); return; }
+          ctx.ui.notify("Saved " + role + " fallbacks (" + scope + ")", "info");
           return;
         }
         if (verb === "cycle") { await this.cycle(ctx); return; }