pi-jar 0.1.3 → 0.1.5

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

@@ -11,7 +11,11 @@ export const BUILTIN_ROLES = [
   { role: "plan", label: "Architect", usedBy: "plan mode" },
   { role: "implement", label: "Builder", usedBy: "goal implement rounds and approved plans" },
   { role: "advisor", label: "Advisor", usedBy: "second opinions, stuck-work gates and the goal audit" },
-  { role: "task", label: "Subtask", usedBy: "delegated tasks" },
+  { role: "moderator", label: "Moderator", usedBy: "main-agent multi-agent coordination" },
+  { role: "scout", label: "Scout", usedBy: "cheap delegated discovery and codebase scouting" },
+  { role: "worker", label: "Worker", usedBy: "sandboxed delegated implementation" },
+  { role: "reviewer", label: "Reviewer", usedBy: "forked delegated review and verification" },
+  { role: "task", label: "Subtask", usedBy: "legacy or explicitly generic delegated tasks" },
   { role: "commit", label: "Commit", usedBy: "/jar commit messages" }
 ] as const;
 export const MODEL_ROLES = BUILTIN_ROLES.map((item) => item.role);
@@ -21,10 +25,10 @@ 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;
+  spec?: string; scope?: RoleScope; resolved?: ResolvedRole; error?: string; fallbacks: string[];
 }
 
 export const ROLE_FILE = "pi-jar-roles.json";
@@ -67,6 +71,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 +158,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;
@@ -167,6 +184,23 @@ export class ModelRoleManager {
     return result && !("error" in result) ? result : undefined;
   }
 
+  /** Primary role target followed by its configured fallbacks, de-duplicated in priority order. */
+  resolveCandidates(role: string): ResolvedRole[] {
+    const candidates: ResolvedRole[] = [];
+    const primary = this.resolve(role);
+    if (primary) candidates.push(primary);
+    for (const spec of this.fallbackSpecs(role)) {
+      try { candidates.push(this.resolveSpec(spec)); } catch { /* malformed alias targets are skipped */ }
+    }
+    const seen = new Set<string>();
+    return candidates.filter((item) => {
+      const key = item.provider + "/" + item.model + ":" + (item.thinking ?? "");
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+  }
+
   get(role: string): RoleAssignment | undefined {
     const resolved = this.resolve(role);
     if (!resolved) return undefined;
@@ -183,17 +217,21 @@ export class ModelRoleManager {
     ];
     return rows.map((row) => {
       const result = resolveRole(roles, row.role);
-      return { ...row, spec: roles[row.role], scope: this.scopeOf(row.role),
+      return { ...row, spec: roles[row.role], scope: this.scopeOf(row.role), fallbacks: this.fallbackSpecs(row.role),
         ...(result && "error" in result ? { error: result.error } : result ? { resolved: result } : {}) };
     });
   }
 
-  /** 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 {
@@ -202,39 +240,46 @@ export class ModelRoleManager {
   }
 
   async activate(role: string, ctx: ExtensionContext, quiet = false): Promise<boolean> {
-    const result = resolveRole(this.merged(), role);
-    if (result && "error" in result) {
-      if (!quiet) ctx.ui.notify("Role " + role + ": " + result.error, "warning");
-      return false;
-    }
-    if (!result) {
+    const primary = resolveRole(this.merged(), role);
+    const primaryError = primary && "error" in primary ? primary.error : undefined;
+    const candidates = this.resolveCandidates(role);
+    if (!candidates.length) {
+      if (primaryError) {
+        if (!quiet) ctx.ui.notify("Role " + role + ": " + primaryError, "warning");
+        return false;
+      }
       if (!quiet) ctx.ui.notify("Role " + role + " follows the current model; assign one with /roles", "info");
       this.active = role;
       this.status(ctx);
       return true;
     }
-    const model = ctx.modelRegistry.find(result.provider, result.model);
-    if (!model) {
-      if (!quiet) ctx.ui.notify("Model not found for role " + role + ": " + result.provider + "/" + result.model, "warning");
-      return false;
-    }
-    let changed: boolean;
-    this.applying = true;
-    try { changed = await this.pi.setModel(model); } finally { this.applying = false; }
-    if (!changed) {
-      if (!quiet) ctx.ui.notify("No configured authentication for " + result.provider + "/" + result.model, "warning");
-      return false;
+
+    const failures: string[] = [];
+    for (let index = 0; index < candidates.length; index++) {
+      const candidate = candidates[index]!;
+      const model = ctx.modelRegistry.find(candidate.provider, candidate.model);
+      if (!model) { failures.push(candidate.provider + "/" + candidate.model + " not found"); continue; }
+      let changed: boolean;
+      this.applying = true;
+      try { changed = await this.pi.setModel(model); } finally { this.applying = false; }
+      if (!changed) { failures.push(candidate.provider + "/" + candidate.model + " unavailable"); continue; }
+      if (candidate.thinking) this.withApplying(() => this.pi.setThinkingLevel(candidate.thinking!));
+      this.active = role;
+      this.status(ctx);
+      if (!quiet) {
+        ctx.ui.notify("Role " + role + " · " + candidate.provider + "/" + candidate.model
+          + (candidate.thinking ? " · " + candidate.thinking : "") + (index ? " · fallback " + index : ""), "info");
+      }
+      return true;
     }
-    if (result.thinking) this.withApplying(() => this.pi.setThinkingLevel(result.thinking!));
-    this.active = role;
-    this.status(ctx);
-    if (!quiet) ctx.ui.notify("Role " + role + " · " + result.provider + "/" + result.model + (result.thinking ? " · " + result.thinking : ""), "info");
-    return true;
+
+    if (!quiet) ctx.ui.notify("No usable model for role " + role + ": " + failures.join("; "), "warning");
+    return false;
   }
 
   /** Switch to a role for a bounded workflow; the returned function restores the previous model. */
   async activateTemporary(role: string, ctx: ExtensionContext): Promise<() => Promise<void>> {
-    if (!this.resolve(role)) return async () => {};
+    if (!this.resolveCandidates(role).length) return async () => {};
     const previousModel = ctx.model;
     const previousThinking = this.pi.getThinkingLevel();
     const previousActive = this.active;
@@ -259,7 +304,7 @@ export class ModelRoleManager {
 
   /** Activate the next assigned role in the cycle order. */
   async cycle(ctx: ExtensionContext): Promise<string | undefined> {
-    const order = this.cycleOrder().filter((role) => this.resolve(role));
+    const order = this.cycleOrder().filter((role) => this.resolveCandidates(role).length > 0);
     if (!order.length) { ctx.ui.notify("No roles in the cycle order are assigned; configure them with /roles", "info"); return undefined; }
     const next = order[(order.indexOf(this.active ?? "") + 1) % order.length]!;
     return await this.activate(next, ctx) ? next : undefined;
@@ -279,7 +324,33 @@ export class ModelRoleManager {
     if (scope === "project") this.project = next; else this.global = next;
   }
 
-  register(openUi?: (ctx: ExtensionContext) => Promise<void>): void {
+  /** 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>, options: { activateDefault?: () => boolean } = {}): void {
     const manual = (_event: unknown, ctx: ExtensionContext) => {
       if (this.applying) return;
       this.manualEpoch++;
@@ -290,17 +361,30 @@ export class ModelRoleManager {
     this.pi.on("session_start", async (_event, ctx) => {
       this.load(ctx.cwd);
       this.active = undefined;
-      if (this.resolve("default")) await this.activate("default", ctx, true);
+      // Delegated children already received their role model/effort via CLI arguments.
+      if (options.activateDefault?.() !== false && this.resolveCandidates("default").length) await this.activate("default", ctx, true);
     });
 
     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/roles-ui.ts

@@ -4,10 +4,11 @@ import { promptText } from "./dialogs.ts";
 import { isRoleName, normalizeSpec, THINKING, type ModelRoleManager, type RoleRow } from "./model-roles.ts";
 import { contentRows, optionList, sidebarWidth, splitFrame } from "./split-view.ts";
 
-type RoleAction = "model" | "alias" | "thinking" | "scope" | "activate" | "clear" | "new" | "delete";
+type RoleAction = "model" | "fallback" | "alias" | "thinking" | "scope" | "activate" | "clear" | "new" | "delete";
 const ACTIONS: { action: RoleAction; key: string; hint: string; label: string }[] = [
   { action: "activate", key: "\r", hint: "⏎", label: "Activate this role now" },
   { action: "model", key: "m", hint: "m", label: "Assign a model" },
+  { action: "fallback", key: "f", hint: "f", label: "Set fallback model" },
   { action: "alias", key: "a", hint: "a", label: "Alias another role (@role)" },
   { action: "thinking", key: "t", hint: "t", label: "Set thinking effort" },
   { action: "scope", key: "s", hint: "s", label: "Move between global and project" },
@@ -28,6 +29,7 @@ function detail(row: RoleRow, active: string | undefined): [ThemeColor, string][
     [target[0], "Model     " + target[1]],
     ["muted", "Alias     " + (row.resolved && row.resolved.via.length > 1 ? row.resolved.via.join(" → ") : "—")],
     ["muted", "Effort    " + (row.resolved?.thinking ?? "follow current")],
+    ["muted", "Fallback  " + (row.fallbacks.length ? row.fallbacks.join(" → ") : "—")],
     ["muted", "Scope     " + (row.scope ?? "unset") + (row.scope === "project" ? "  (.pi/pi-jar-roles.json)" : row.scope === "global" ? "  (agent dir)" : "")],
     ["dim", ""],
     ["dim", "Specs: provider/model[:effort] · @role[:effort] · *"],
@@ -41,7 +43,6 @@ async function roleScreen(ctx: ExtensionContext, roles: ModelRoleManager, initia
     let scroll = 0;
     let layout = { top: 1, rows: 0, leftWidth: 0, bodyX: 2, footerTop: 0 };
     let width = 80;
-    let actionsTop = -1;
     const rows = () => roles.list();
     const finish = (action: RoleAction) => done({ action, index: selected });
     return {
@@ -67,9 +68,9 @@ async function roleScreen(ctx: ExtensionContext, roles: ModelRoleManager, initia
         if (event.type !== "click" || event.button !== "left") return;
         if (event.y === 0 && event.x >= width - 3) { done(undefined); return { handled: true }; }
         const row = event.y - layout.top;
-        // Actions are listed in the detail pane, one per row.
-        const actionIndex = row - actionsTop;
-        if (row >= 0 && row < layout.rows && event.x >= layout.bodyX && actionIndex >= 0 && actionIndex < ACTIONS.length) {
+        // Actions stay in the footer so even short terminals can click every action.
+        const actionIndex = event.y - layout.footerTop;
+        if (event.x >= 2 && event.x < width - 2 && actionIndex >= 0 && actionIndex < ACTIONS.length) {
           finish(ACTIONS[actionIndex]!.action); return { handled: true };
         }
         if (row >= 0 && row < layout.rows && (layout.leftWidth === 0 || event.x < layout.leftWidth + 3)) {
@@ -81,7 +82,7 @@ async function roleScreen(ctx: ExtensionContext, roles: ModelRoleManager, initia
         width = Math.max(24, available);
         const list = rows();
         selected = Math.max(0, Math.min(list.length - 1, selected));
-        const height = Math.min(contentRows(5, 8), Math.max(12 + ACTIONS.length + 2, list.length));
+        const height = Math.min(contentRows(ACTIONS.length + 4, 4), Math.max(13, list.length));
         if (selected < scroll) scroll = selected;
         if (selected >= scroll + height) scroll = selected - height + 1;
         const active = roles.activeRole();
@@ -97,11 +98,9 @@ async function roleScreen(ctx: ExtensionContext, roles: ModelRoleManager, initia
         const header = narrow ? [theme.fg("accent", `‹ ${selected + 1}/${list.length} ${row.role} ›`)] : [];
         const actions = optionList(theme, ACTIONS.map((item) => item.label), -1, ACTIONS.map((item) => item.hint))
           .map((line, at) => ACTIONS[at]!.action === "delete" && !row.custom ? theme.fg("dim", stripTerminalSequences(line)) : line);
-        // Actions come right after the facts; the spec help (last three lines) goes last.
-        const facts = info.slice(0, -3), help = info.slice(-3);
-        const body = [...header, ...facts, theme.fg("accent", "Actions"), ...actions, ...help];
-        actionsTop = header.length + facts.length + 1;
+        const body = [...header, ...info];
         const split = splitFrame(theme, width, "pi-jar · roles", narrow ? [] : left, body, [
+          ...actions,
           theme.fg("dim", "↑↓ choose role · press a key or click an action · Esc close")
         ], height);
         layout = split.layout;
@@ -149,6 +148,15 @@ async function applyAction(ctx: ExtensionContext, roles: ModelRoleManager, row:
       if (selected) roles.update(row.role, selected + effort(), scope);
       return;
     }
+    case "fallback": {
+      const models = ctx.modelRegistry.getAvailable().slice().sort((a, b) => (a.provider + "/" + a.id).localeCompare(b.provider + "/" + b.id));
+      if (!models.length) { ctx.ui.notify("No authenticated models are currently available", "warning"); return; }
+      const choices = ["Clear fallback", ...models.map((model) => model.provider + "/" + model.id)];
+      const selected = await ctx.ui.select("Fallback model for " + row.role, choices);
+      if (!selected) return;
+      roles.updateFallbacks(row.role, selected === "Clear fallback" ? [] : [selected], scope);
+      return;
+    }
     case "alias": {
       const targets = roles.list().filter((item) => item.role !== row.role).map((item) => "@" + item.role);
       const selected = await ctx.ui.select("Alias " + row.role + " to", targets);

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