pi-jar 0.1.3 → 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,7 +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 { 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";
@@ -53,6 +53,12 @@ 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);
@@ -70,10 +76,15 @@ function activityRow(item: FooterActivity, width: number, theme: FooterTheme): s
   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 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 gap = " ".repeat(Math.max(1, width - visibleWidth(head) - visibleWidth(detail) - visibleWidth(stats)));
-  return truncateToWidth(head + detail + (stats ? gap + stats : ""), width);
+  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 {
@@ -94,11 +105,18 @@ export function renderFooter(view: FooterView, width: number, theme: FooterTheme
   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 hits: FooterHit[] = [];
-  const lines = footerLines(view, width, theme, hits);
-  return { lines, hits };
+  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[] {
@@ -123,11 +141,7 @@ function footerLines(view: FooterView, width: number, theme: FooterTheme, hits:
   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], THINKING_ICONS[view.effort] ? withIcon(THINKING_ICONS[view.effort]!, 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.
@@ -168,12 +182,16 @@ function footerLines(view: FooterView, width: number, theme: FooterTheme, hits:
     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)];
+  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 && memory ? [memory] : []), ...(show.quota ? windows : [])];

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

package/src/panel.ts

@@ -1,5 +1,6 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Key, matchesKey, truncateToWidth, visibleWidth, type TuiMouseEvent } from "@earendil-works/pi-tui";
+import { RowCache } from "./row-cache.ts";
 
 export type Paint = (color: string, text: string) => string;
 export interface PanelTab { name: string; render(width: number, fg: Paint): string[] }
@@ -13,6 +14,8 @@ export async function openPanel(ctx: ExtensionContext, tabs: readonly PanelTab[]
     let body: string[] = [];
     let rows = 10;
     let tabHits: { start: number; end: number }[] = [];
+    // The panel repaints on every Pi render while open; its body rows rarely change between frames.
+    const framed = new RowCache();
     const fg: Paint = (color, text) => theme.fg(color as never, text);
     const move = (delta: number) => { scroll = Math.max(0, Math.min(Math.max(0, body.length - rows), scroll + delta)); };
     const select = (index: number) => { tab = (index + tabs.length) % tabs.length; scroll = 0; };
@@ -40,7 +43,8 @@ export async function openPanel(ctx: ExtensionContext, tabs: readonly PanelTab[]
         rows = Math.max(4, (process.stdout.rows ?? 24) - 6);
         body = tabs[tab]!.render(inner, fg);
         scroll = Math.min(scroll, Math.max(0, body.length - rows));
-        const line = (text: string) => fg("dim", "│ ") + truncateToWidth(text, inner) + " ".repeat(Math.max(0, inner - visibleWidth(truncateToWidth(text, inner)))) + fg("dim", " │");
+        framed.begin(`${inner}\0${fg("dim", "│")}`);
+        const line = (text: string) => framed.get(text, (row) => fg("dim", "│ ") + truncateToWidth(row, inner, "...", true) + fg("dim", " │"));
         tabHits = [];
         // Every tab label is name + 2 cells wide ("[name]" or " name "), separated by one space.
         let x = 2;

package/src/prompt-search.ts

@@ -1,5 +1,5 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { fuzzyFilter, Key, matchesKey, truncateToWidth, visibleWidth, type TuiMouseEvent } from "@earendil-works/pi-tui";
+import { fuzzyFilter, Key, matchesKey, truncateToWidth, type TuiMouseEvent } from "@earendil-works/pi-tui";
 import { cleanText } from "./status.ts";
 
 export interface PastPrompt { text: string; source: "this session" | "earlier session"; at?: number }
@@ -58,6 +58,13 @@ export async function openPromptSearch(ctx: ExtensionContext, prompts: readonly
     let visible: PastPrompt[] = pool;
     const rows = 10;
     const filter = () => { visible = query ? fuzzyFilter(pool, query, (item) => item.text) : pool; selected = 0; first = 0; };
+    // Prompts can be several KiB; sanitize each once, not on every repaint.
+    const cleaned = new Map<PastPrompt, string>();
+    const preview = (item: PastPrompt) => {
+      let text = cleaned.get(item);
+      if (text === undefined) cleaned.set(item, text = cleanText(item.text, 400));
+      return text;
+    };
     return {
       invalidate() {},
       handleInput(data: string) {
@@ -81,21 +88,22 @@ export async function openPromptSearch(ctx: ExtensionContext, prompts: readonly
         const inner = w - 4;
         if (selected < first) first = selected;
         if (selected >= first + rows) first = selected - rows + 1;
-        const fit = (text: string) => { const value = truncateToWidth(text, inner); return value + " ".repeat(Math.max(0, inner - visibleWidth(value))); };
         const dim = (text: string) => theme.fg("dim", text);
+        // Rows are exactly `w` wide; only the two borders can overflow a narrow overlay.
         const lines = [
-          theme.fg("accent", "╭─ ⌕ PROMPT HISTORY ") + dim("─".repeat(Math.max(0, w - 21)) + "╮"),
-          dim("│ ") + fit(theme.fg("accent", "› ") + query + "\x1b[7m \x1b[0m" + dim(`  ${visible.length}/${prompts.length}`)) + dim(" │")
+          truncateToWidth(theme.fg("accent", "╭─ ⌕ PROMPT HISTORY ") + dim("─".repeat(Math.max(0, w - 21)) + "╮"), w),
+          dim("│ ") + truncateToWidth(theme.fg("accent", "› ") + query + "\x1b[7m \x1b[0m" + dim(`  ${visible.length}/${prompts.length}`), inner, "...", true) + dim(" │")
         ];
         for (let row = 0; row < rows; row++) {
           const item = visible[first + row];
           const active = first + row === selected;
-          const text = item ? (active ? "❯ " : "  ") + cleanText(item.text, 400) : "";
+          const text = item ? (active ? "❯ " : "  ") + preview(item) : "";
           const tag = item?.source === "earlier session" ? dim(" · earlier") : "";
-          lines.push(dim("│ ") + fit(item ? theme.fg(active ? "accent" : "muted", truncateToWidth(text, Math.max(4, inner - 10))) + tag : "") + dim(" │"));
+          const content = item ? theme.fg(active ? "accent" : "muted", truncateToWidth(text, Math.max(4, inner - 10))) + tag : "";
+          lines.push(dim("│ ") + truncateToWidth(content, inner, "...", true) + dim(" │"));
         }
-        lines.push(dim("╰─ type to filter · ↑↓ select · Enter edit · Esc close " + "─".repeat(Math.max(0, w - 57)) + "╯"));
-        return lines.map((line) => truncateToWidth(line, w));
+        lines.push(truncateToWidth(dim("╰─ type to filter · ↑↓ select · Enter edit · Esc close " + "─".repeat(Math.max(0, w - 57)) + "╯"), w));
+        return lines;
       }
     };
   }, { overlay: true, overlayOptions: { width: "80%", maxHeight: "60%" } });

package/src/row-cache.ts

@@ -0,0 +1,26 @@
+/**
+ * Row memo across consecutive renders. pi-tui re-segments every grapheme on each truncate, and pi-jar's
+ * chrome and overlays repaint on every Pi render (each streamed token) with mostly the same rows, or one
+ * changed row while typing or scrolling. Rows transformed by the previous render are reused while the
+ * scope (width, painter sample) holds, so memory stays bounded by two renders' rows.
+ */
+export class RowCache {
+  private previous = new Map<string, string>();
+  private current = new Map<string, string>();
+  private scope: string | undefined;
+
+  /** Start a render. A different scope drops every cached row. */
+  begin(scope: string): void {
+    this.previous = scope === this.scope ? this.current : new Map();
+    this.current = new Map();
+    this.scope = scope;
+  }
+
+  /** `transform(row)` for this render; `transform` may depend only on the row and the scope. */
+  get(row: string, transform: (row: string) => string): string {
+    let value = this.current.get(row) ?? this.previous.get(row);
+    if (value === undefined) value = transform(row);
+    this.current.set(row, value);
+    return value;
+  }
+}

package/src/session-ui.ts

@@ -1,7 +1,7 @@
 import type { ExtensionContext, SessionInfo } from "@earendil-works/pi-coding-agent";
 import { Key, matchesKey, truncateToWidth, wrapTextWithAnsi, type TuiMouseEvent } from "@earendil-works/pi-tui";
 import { sessionDisplayName } from "./composer.ts";
-import { withIcon } from "./icons.ts";
+import { iconSet, withIcon } from "./icons.ts";
 import { contentRows, sidebarWidth, splitFrame } from "./split-view.ts";
 import { cleanText } from "./status.ts";
 
@@ -68,8 +68,13 @@ export async function pickSession(ctx: ExtensionContext, sessions: readonly Sess
       const settle = (value: SessionDetails) => { if (closed) return; cache.set(session.path, value); tui.requestRender(); };
       Promise.resolve().then(() => details(session)).then((value) => settle(value ?? {}), () => settle({}));
     };
+    // Wrapping a 4 KiB first prompt is the costliest part of a frame; redo it only when its inputs change.
+    let described: { session: SessionInfo; inputs: string; loaded: SessionDetails | null | undefined; lines: string[] } | undefined;
     const describe = (session: SessionInfo, bodyWidth: number, height: number): string[] => {
       const date = session.modified;
+      const inputs = `${bodyWidth}\0${height}\0${age(date)}\0${iconSet()}`;
+      const loaded = details ? cache.get(session.path) : undefined;
+      if (described?.session === session && described.inputs === inputs && described.loaded === loaded) return described.lines;
       const when = Number.isNaN(date.getTime()) ? "unknown"
         : `${date.getFullYear()}-${two(date.getMonth() + 1)}-${two(date.getDate())} ${two(date.getHours())}:${two(date.getMinutes())}` + (age(date) ? ` · ${age(date)} ago` : "");
       const lines = [
@@ -80,7 +85,6 @@ export async function pickSession(ctx: ExtensionContext, sessions: readonly Sess
       ];
       if (session.cwd) lines.push(fg("muted", withIcon("folder", cleanText(session.cwd, 400))));
       if (details) {
-        const loaded = cache.get(session.path);
         if (!loaded) lines.push(fg("dim", "Loading details…"));
         else {
           for (const [key, text] of [["goal", loaded.goal], ["plan", loaded.plan]] as const) {
@@ -91,10 +95,11 @@ export async function pickSession(ctx: ExtensionContext, sessions: readonly Sess
       lines.push("", fg("dim", "First prompt"));
       const prompt = cleanText(session.firstMessage, 4096);
       lines.push(...(prompt ? wrapTextWithAnsi(prompt, Math.max(1, bodyWidth)).map((line) => fg("muted", line)) : [fg("dim", "No first prompt")]));
-      return lines.slice(0, height).map((line) => truncateToWidth(line, Math.max(0, bodyWidth)));
+      described = { session, inputs, loaded, lines: lines.slice(0, height).map((line) => truncateToWidth(line, Math.max(0, bodyWidth))) };
+      return described.lines;
     };
     return {
-      invalidate() {},
+      invalidate() { described = undefined; },
       handleInput(data: string) {
         if (matchesKey(data, Key.escape)) return finish(undefined);
         if (matchesKey(data, Key.enter)) return finish(rows[selected]?.path);

package/src/settings-ui.ts

@@ -111,12 +111,8 @@ export async function openJarSettings(
       render(available: number): string[] {
         width = Math.max(8, available);
         const state = current();
-        const fit = (text: string) => truncateToWidth(text, width);
-        const line = (text: string) => {
-          const inner = Math.max(0, width - 5);
-          const content = truncateToWidth(text, inner);
-          return fit(theme.fg("dim", "│  ") + content + " ".repeat(Math.max(0, inner - visibleWidth(content))) + theme.fg("dim", " │"));
-        };
+        // Rows are assembled from exact-width parts, so one truncate-and-pad pass per row is enough.
+        const line = (text: string) => theme.fg("dim", "│  ") + truncateToWidth(text, Math.max(0, width - 5), "...", true) + theme.fg("dim", " │");
         const title = " pi-jar · settings ";
         const top = theme.fg("accent", "╭─" + truncateToWidth(title, Math.max(0, width - 6))
           + "─".repeat(Math.max(0, width - 4 - visibleWidth(title))) + "×╮");
@@ -144,13 +140,13 @@ export async function openJarSettings(
           ];
         const start = firstVisible();
         const rows = allRows.slice(start, start + pageSize());
-        return [fit(top), tabs, divider,
+        return [top, tabs, divider,
           line(theme.fg("accent", page === "footer" ? " FOOTER VISIBILITY" : page === "pi" ? " PI & WORKFLOWS" : " APPEARANCE & MOTION")),
           line(theme.fg("dim", page === "footer" ? ` Footer fields ${start + 1}–${start + rows.length}/${fields()}`
             : page === "pi" ? " Fullscreen mode enables clicks and copy-on-select" : " Accent cycles through loaded themes")),
-          ...rows.map(fit),
+          ...rows,
           line(theme.fg("dim", " Tab: section · ↑↓: choose · Enter/click: change · Esc")),
-          fit(theme.fg("dim", "╰" + "─".repeat(Math.max(0, width - 2)) + "╯"))];
+          theme.fg("dim", "╰" + "─".repeat(Math.max(0, width - 2)) + "╯")];
       }
     };
   });

package/src/shells.ts

@@ -53,10 +53,11 @@ export class ShellManager {
   constructor(onEvent: (event: ShellEvent) => void, spawnShell: typeof spawn = spawn) { this.onEvent = onEvent; this.spawnShell = spawnShell; }
 
   list(): ShellJob[] { return [...this.jobs.values()].map(({ job }) => ({ ...job, lines: [...job.lines] })); }
+  /** Read by the footer on every render: one shallow copy per job, never the output lines. */
   summaries(): Array<Omit<ShellJob, "lines">> {
     return [...this.jobs.values()].map(({ job }) => {
       const { lines: _lines, ...summary } = job;
-      return { ...summary };
+      return summary;
     });
   }
   get(id: string): ShellJob | undefined { const entry = this.jobs.get(id); return entry && { ...entry.job, lines: [...entry.job.lines] }; }