pi-jar 0.1.1 → 0.1.3

package/src/composer.ts

@@ -4,6 +4,11 @@ import { Mascot, MASCOT_FACE_WIDTH, mascotFace, paintFace, paintTip, type Mascot
 import type { SuggestionState } from "./suggest.ts";
 import type { WorkingPhase } from "./working.ts";
 import { imageChip, imageInfo, imagePaths } from "./attachments.ts";
+// Aliased: roundedInput has a parameter named `icon`.
+import { icon as glyph, type IconKey } from "./icons.ts";
+
+/** `⏎ send`; ascii spells the key out (`enter send`). */
+const keyHint = (key: IconKey, action: string) => glyph(key) + " " + action;
 
 type EditorFactory = NonNullable<ReturnType<ExtensionContext["ui"]["getEditorComponent"]>>;
 type MouseEvent = Parameters<NonNullable<EditorComponent["handleMouse"]>>[0];
@@ -12,6 +17,8 @@ const PHASE_MOODS: Record<WorkingPhase, readonly MascotMood[]> = {
   idle: ["idle"], generating: ["happy", "thinking"], tool: ["tool"], waiting: ["waiting"]
 };
 export const COMPOSER_ACTIVE_INTERVAL_MS = 600;
+/** How long composer image chips trust a previous filesystem check for the same draft. */
+const ATTACHMENT_RECHECK_MS = 1000;
 /** Plain one-line face for a phase; every phase has the same width. */
 export function composerIcon(phase: WorkingPhase, frame = 0): string {
   const moods = PHASE_MOODS[phase];
@@ -95,7 +102,9 @@ export function roundedInput(lines: string[], width: number, focused: boolean, t
     if (index === 0 && options.ghost && row.includes(CURSOR)) {
       const base = row.replace(/ +$/, "");
       const room = inner - visibleWidth(base);
-      if (room > 2) row = base + dim(truncateToWidth(options.ghost + "   ⇥ tab", room, "…"));
+      // ascii's tab "icon" is already the word.
+      const tab = glyph("tab") === "tab" ? "tab" : keyHint("tab", "tab");
+      if (room > 2) row = base + dim(truncateToWidth(options.ghost + "   " + tab, room, "…"));
     }
     const fitted = truncateToWidth(row, inner);
     return border("│") + fitted + " ".repeat(Math.max(0, inner - visibleWidth(fitted))) + border("│");
@@ -159,7 +168,9 @@ class RoundedEditor extends CustomEditor {
 
   override render(width: number): string[] {
     const inner = this.renderTall(width < 8 ? width : width - 2);
-    const empty = this.getText() === "";
+    const text = this.getText();
+    const empty = text === "";
+    const below = this.decor.attachments(text);
     const ghost = empty && !this.isShowingAutocomplete() ? this.decor.ghost() : undefined;
     this.ghostShown = !!ghost;
     const visibleRows = (this as unknown as { renderedVisibleLineCount?: number }).renderedVisibleLineCount;
@@ -167,7 +178,7 @@ class RoundedEditor extends CustomEditor {
       ...(ghost ? { ghost } : {}), ...(this.decor.hint() ? { hint: this.decor.hint()! } : {}),
       ...(this.decor.paintedIcon() ? { paintedIcon: this.decor.paintedIcon()! } : {}),
       ...(visibleRows != null ? { visibleRows } : {}), dim: this.decor.dim,
-      ...(this.decor.attachments(this.getText()) ? { below: this.decor.attachments(this.getText())! } : {})
+      ...(below ? { below } : {})
     });
     const tip = width >= 8 ? this.decor.tip(width) : undefined;
     this.tipRows = tip ? 1 : 0;
@@ -230,10 +241,12 @@ class ThemedEditor implements EditorComponent {
   }
   invalidate() { this.base.invalidate(); }
   render(width: number): string[] {
-    const ghost = this.base.getText() === "" ? this.decor.ghost() : undefined;
+    const text = this.base.getText();
+    const ghost = text === "" ? this.decor.ghost() : undefined;
+    const below = this.decor.attachments(text);
     const framed = roundedInput(this.base.render(width < 8 ? width : width - 2), width, this.focused, this.theme, this.paint, this.decor.icon(), this.decor.session(), {
       ...(ghost ? { ghost } : {}), ...(this.decor.paintedIcon() ? { paintedIcon: this.decor.paintedIcon()! } : {}), dim: this.decor.dim,
-      ...(this.decor.attachments(this.base.getText()) ? { below: this.decor.attachments(this.base.getText())! } : {})
+      ...(below ? { below } : {})
     });
     const tip = width >= 8 ? this.decor.tip(width) : undefined;
     this.tipRows = tip ? 1 : 0;
@@ -269,6 +282,8 @@ export class ComposerStyle {
   private suggestions?: SuggestionState;
   private unsubscribe?: () => void;
   private colors?: { fg(color: string, text: string): string };
+  /** Chips for the last draft; image paths hit the filesystem, so reuse them briefly across repaints. */
+  private chips?: { text: string; cwd: string; at: number; chips: string[] };
 
   private readonly decor: ComposerDecor = {
     icon: () => this.mascotOn ? mascotFace(this.animations ? this.mascot.mood() : "idle") : "pi",
@@ -280,12 +295,15 @@ export class ComposerStyle {
     tip: (width) => {
       if (!this.mascotOn || width < 40) return undefined;
       const mood = this.animations ? this.mascot.mood() : "idle";
-      const tip = this.animations ? this.mascot.tip(Date.now(), this.frame) : this.mascot.tip(0, 0);
+      const animationFrame = this.phase === "idle" ? this.frame : Math.floor(Date.now() / COMPOSER_ACTIVE_INTERVAL_MS);
+      const tip = this.animations ? this.mascot.tip(Date.now(), animationFrame) : this.mascot.tip(0, 0);
       return " ".repeat(3) + paintTip(tip, mood, this.colors ? (color, text) => this.colors!.fg(color, text) : undefined);
     },
     session: () => this.session,
     ghost: () => this.suggestions?.text,
-    hint: () => this.suggestions?.text ? "⇥ accept · ⏎ send · ⇧⏎ newline" : "⏎ send · ⇧⏎ newline · /plan · /goal",
+    hint: () => this.suggestions?.text
+      ? `${keyHint("tab", "accept")} · ${keyHint("enter", "send")} · ${keyHint("shiftEnter", "newline")}`
+      : `${keyHint("enter", "send")} · ${keyHint("shiftEnter", "newline")} · /plan · /goal`,
     accept: () => {
       const text = this.suggestions?.text;
       if (text) this.suggestions!.clear();
@@ -296,9 +314,13 @@ export class ComposerStyle {
     dim: (text) => this.colors?.fg("dim", text) ?? `\x1b[2m${text}\x1b[22m`,
     attachments: (text) => {
       if (!/\.(png|jpe?g|gif|webp)\b/i.test(text)) return undefined;
-      const chips = imagePaths(text, this.cwd).map(imageInfo).filter((info) => !!info).map((info) => imageChip(info!));
-      if (!chips.length) return undefined;
-      return chips.map((chip) => this.colors?.fg("accent", chip) ?? chip).join(this.colors?.fg("dim", "   ") ?? "   ");
+      const now = Date.now();
+      if (this.chips?.text !== text || this.chips.cwd !== this.cwd || now - this.chips.at >= ATTACHMENT_RECHECK_MS) {
+        const chips = imagePaths(text, this.cwd).map(imageInfo).filter((info) => !!info).map((info) => imageChip(info!));
+        this.chips = { text, cwd: this.cwd, at: now, chips };
+      }
+      if (!this.chips.chips.length) return undefined;
+      return this.chips.chips.map((chip) => this.colors?.fg("accent", chip) ?? chip).join(this.colors?.fg("dim", "   ") ?? "   ");
     }
   };
 
@@ -335,8 +357,9 @@ export class ComposerStyle {
   }
 
   /**
-   * Active motion ticks at a modest 600 ms. Idle motion has no polling loop at all: it sleeps
-   * until the mascot's next blink/sleep/flash deadline, then schedules the following deadline.
+   * Pi's own streaming/tool updates already repaint active sessions. Never add another active
+   * animation loop: active frames derive from wall time when Pi naturally renders. Idle only
+   * schedules exact blink/sleep/flash transitions.
    */
   private restartTimer(): void {
     this.stopTimer();
@@ -346,8 +369,7 @@ export class ComposerStyle {
   }
   private scheduleTimer(): void {
     if (!this.enabled || !this.animations || !this.mascotOn || this.timer) return;
-    const active = this.phase === "generating" || this.phase === "tool" || this.phase === "waiting";
-    const delay = active ? COMPOSER_ACTIVE_INTERVAL_MS : this.mascot.nextTransitionDelay(Date.now());
+    const delay = this.mascot.nextTransitionDelay(Date.now());
     if (delay === undefined) return;
     this.timer = setTimeout(() => {
       this.timer = undefined;

package/src/delegate.ts

@@ -15,7 +15,17 @@ export const MAX_DELEGATES = 4;
 export const READ_ONLY_TOOLS = ["read", "grep", "find", "ls"] as const;
 const MAX_OUTPUT_CHARS = 12_000;
 const TIMEOUT_MS = 20 * 60_000;
-const STATUS_REFRESH_MS = 10_000;
+const STATUS_REFRESH_MS = 20_000;
+const LIVE_UPDATE_MS = 1000;
+const MAX_EVENT_TEXT = 16_000;
+const MAX_LOG_LINES = 200;
+const MAX_LOG_CHARS = 240;
+/** Finished subagents the registry keeps for the activity view after their tool call returns. */
+const MAX_FINISHED = 8;
+/** Abort reason for stopping one subagent from the activity view (vs. aborting the whole tool call). */
+const STOP_REASON = "stopped";
+/** Tool arguments that best describe a call in the transcript, most telling first. */
+const HINT_KEYS = ["command", "path", "file_path", "pattern", "query", "url"] as const;
 
 export type DelegateState = "queued" | "working" | "done" | "failed";
 export interface DelegateRun {
@@ -31,6 +41,10 @@ export interface DelegateRun {
   cost: number;
   output: string;
   error?: string;
+  startedAt?: number;
+  endedAt?: number;
+  /** Live transcript (tool calls, assistant text), last MAX_LOG_LINES; never copied into tool details. */
+  log: string[];
 }
 
 type Spawn = (command: string, args: string[], options: Parameters<typeof spawn>[2]) => ChildProcess;
@@ -56,9 +70,44 @@ export function delegateArgs(task: string, model: string | undefined, thinking:
   return args;
 }
 
-const textOf = (message: { content?: unknown }) => Array.isArray(message.content)
-  ? message.content.filter((part: { type?: string }) => part?.type === "text").map((part: { text?: string }) => part.text ?? "").join("\n")
-  : typeof message.content === "string" ? message.content : "";
+const textOf = (message: { content?: unknown }, limit = MAX_EVENT_TEXT): string => {
+  if (typeof message.content === "string") return message.content.slice(0, limit);
+  if (!Array.isArray(message.content)) return "";
+  let out = "";
+  for (const part of message.content as Array<{ type?: string; text?: string }>) {
+    if (part?.type !== "text" || typeof part.text !== "string" || !part.text) continue;
+    const separator = out ? "\n" : "";
+    const room = limit - out.length - separator.length;
+    if (room <= 0) break;
+    out += separator + part.text.slice(0, room);
+    if (part.text.length > room) break;
+  }
+  return out;
+};
+
+/** Append transcript lines, cleaned and clipped, keeping only the newest MAX_LOG_LINES. */
+const appendLog = (run: DelegateRun, lines: readonly string[]) => {
+  for (const raw of lines) { const line = cleanText(raw, MAX_LOG_CHARS); if (line) run.log.push(line); }
+  if (run.log.length > MAX_LOG_LINES) run.log.splice(0, run.log.length - MAX_LOG_LINES);
+};
+
+/** The argument that says what a tool call does: the bash command, the file path, the search pattern… */
+const toolHint = (args: unknown): string => {
+  if (!args || typeof args !== "object") return "";
+  for (const key of HINT_KEYS) {
+    const value = (args as Record<string, unknown>)[key];
+    if (typeof value === "string" && value.trim()) return value;
+  }
+  return "";
+};
+
+/** The slice of Pi's JSON event stream a run reads; leaves are unknown because it is another process's output. */
+interface ChildEvent {
+  type?: unknown;
+  toolName?: unknown;
+  args?: unknown;
+  message?: { role?: unknown; content?: unknown; usage?: { cost?: { total?: unknown } }; stopReason?: unknown; errorMessage?: unknown };
+}
 
 /** Run one child Pi, feeding progress into `run` and calling `update` on every change. */
 export function runDelegate(run: DelegateRun, args: string[], cwd: string, signal: AbortSignal | undefined, update: () => void, spawnProcess: Spawn = spawn as Spawn): Promise<void> {
@@ -68,9 +117,10 @@ export function runDelegate(run: DelegateRun, args: string[], cwd: string, signa
     try {
       child = spawnProcess(invocation.command, invocation.args, { cwd, shell: false, stdio: ["ignore", "pipe", "pipe"], env: { ...process.env, [CHILD_ENV]: "1" } });
     } catch (error) {
-      run.state = "failed"; run.error = error instanceof Error ? error.message : String(error); update(); resolve(); return;
+      run.state = "failed"; run.error = error instanceof Error ? error.message : String(error); run.endedAt = Date.now(); update(); resolve(); return;
     }
     run.state = "working";
+    run.startedAt = Date.now();
     run.activity = "starting";
     update();
     let buffer = "";
@@ -84,25 +134,36 @@ export function runDelegate(run: DelegateRun, args: string[], cwd: string, signa
       run.state = state;
       if (error) run.error = error;
       run.activity = undefined;
+      run.endedAt = Date.now();
       update();
       resolve();
     };
     const stop = () => { child.kill("SIGTERM"); setTimeout(() => { if (child.exitCode === null) child.kill("SIGKILL"); }, 3000).unref?.(); };
-    const abort = () => { stop(); finish("failed", "aborted"); };
+    // Stopping one run from the activity view reads "stopped"; aborting the whole tool call reads "aborted".
+    const abort = () => { stop(); finish("failed", signal?.reason === STOP_REASON ? "stopped" : "aborted"); };
     const timer = setTimeout(() => { stop(); finish("failed", "timed out"); }, TIMEOUT_MS);
     timer.unref?.();
     if (signal?.aborted) { abort(); return; }
     signal?.addEventListener("abort", abort, { once: true });
     const line = (raw: string) => {
-      if (!raw.trim()) return;
-      let event: any;
-      try { event = JSON.parse(raw); } catch { return; }
-      if (event.type === "tool_execution_start") { run.tools++; run.activity = cleanText(String(event.toolName ?? "tool"), 24); update(); }
+      // Output that arrives after an abort or timeout must not revive a finished run's activity.
+      if (finished || !raw.trim()) return;
+      let parsed: unknown;
+      try { parsed = JSON.parse(raw); } catch { return; }
+      if (!parsed || typeof parsed !== "object") return;
+      // Parsed child output: the object check above is all the cast assumes; every field stays unknown until read.
+      const event = parsed as ChildEvent;
+      if (event.type === "tool_execution_start") {
+        run.tools++;
+        run.activity = cleanText(String(event.toolName ?? "tool"), 24);
+        appendLog(run, [`▸ ${run.activity} ${toolHint(event.args)}`]);
+        update();
+      }
       else if (event.type === "message_end" && event.message?.role === "assistant") {
         run.turns++;
         run.cost += Number(event.message.usage?.cost?.total) || 0;
         const text = textOf(event.message).trim();
-        if (text) run.output = text.slice(0, MAX_OUTPUT_CHARS);
+        if (text) { run.output = text.slice(0, MAX_OUTPUT_CHARS); appendLog(run, text.split("\n").slice(-MAX_LOG_LINES)); }
         if (event.message.stopReason === "error" && event.message.errorMessage) run.error = cleanText(String(event.message.errorMessage), 200);
         run.activity = "thinking";
         update();
@@ -124,6 +185,81 @@ export function runDelegate(run: DelegateRun, args: string[], cwd: string, signa
   });
 }
 
+const isActive = (state: DelegateState) => state === "queued" || state === "working";
+
+export interface SubagentRecord { key: string; batch: number; run: DelegateRun; stop(): void }
+
+/**
+ * Live subagents for the activity view. Tool details are saved in the session, so they stay small;
+ * the transcript and the per-run stop handle live only here, for this process.
+ */
+export class DelegateRegistry {
+  private entries = new Map<string, { record: SubagentRecord; finished?: number }>();
+  private listeners = new Set<() => void>();
+  private sequence = 0;
+
+  subscribe(listener: () => void): () => void {
+    this.listeners.add(listener);
+    return () => { this.listeners.delete(listener); };
+  }
+  /** Queued/working first (oldest first), then finished ones newest first. */
+  records(): SubagentRecord[] {
+    this.sweep();
+    const live: SubagentRecord[] = [];
+    const finished: Array<{ record: SubagentRecord; finished: number }> = [];
+    for (const { record, finished: at } of this.entries.values()) {
+      if (at === undefined) live.push(record); else finished.push({ record, finished: at });
+    }
+    finished.sort((a, b) => b.finished - a.finished);
+    return [...live, ...finished.map((entry) => entry.record)];
+  }
+  get(key: string): SubagentRecord | undefined { return this.entries.get(key)?.record; }
+  /** Abort one queued/working run, leaving the rest of its batch alone; false when unknown or already finished. */
+  stop(key: string): boolean {
+    const record = this.entries.get(key)?.record;
+    if (!record || !isActive(record.run.state)) return false;
+    record.stop();
+    this.notify();
+    return true;
+  }
+  running(): number {
+    let count = 0;
+    for (const { record } of this.entries.values()) if (isActive(record.run.state)) count++;
+    return count;
+  }
+  /** Stop outstanding runs on session changes/shutdown and forget their transcript. */
+  clear(): void {
+    const stopping = [...this.entries.values()].filter(({ record }) => isActive(record.run.state)).map(({ record }) => record.stop);
+    this.entries.clear();
+    for (const stop of stopping) stop();
+    this.notify();
+  }
+  /** jar_delegate's side: list new runs. */
+  add(...records: SubagentRecord[]): void {
+    for (const record of records) this.entries.set(record.key, { record });
+    this.notify();
+  }
+  /** jar_delegate's side: a run changed. */
+  notify(): void {
+    this.sweep();
+    for (const listener of this.listeners) {
+      try { listener(); } catch { /* views are decoration; a broken one must not break the run */ }
+    }
+  }
+  /** Stamp runs in the order they finish and keep only the newest MAX_FINISHED of them. */
+  private sweep(): void {
+    let finished = 0;
+    for (const entry of this.entries.values()) {
+      if (isActive(entry.record.run.state)) continue;
+      entry.finished ??= ++this.sequence;
+      finished++;
+    }
+    if (finished <= MAX_FINISHED) return;
+    const oldest = [...this.entries].filter(([, entry]) => entry.finished !== undefined).sort((a, b) => a[1].finished! - b[1].finished!);
+    for (const [key] of oldest.slice(0, finished - MAX_FINISHED)) this.entries.delete(key);
+  }
+}
+
 const Parameters = Type.Object({
   tasks: Type.Array(Type.Object({
     task: Type.String({ description: "A complete, self-contained instruction: the subagent sees nothing else." }),
@@ -136,7 +272,8 @@ const Parameters = Type.Object({
 const glyph = (state: DelegateState) => state === "done" ? "✔" : state === "failed" ? "✖" : state === "working" ? "●" : "○";
 const color = (state: DelegateState) => state === "done" ? "success" : state === "failed" ? "error" : state === "working" ? "accent" : "dim";
 
-export function registerDelegate(pi: ExtensionAPI, roles: ModelRoleManager, spawnProcess?: Spawn): void {
+/** jar_delegate. Every run is listed live in `registry` (with its transcript and a stop handle) for the activity view. */
+export function registerDelegate(pi: ExtensionAPI, roles: ModelRoleManager, registry: DelegateRegistry, spawnProcess?: Spawn): void {
   if (process.env[CHILD_ENV] || typeof (pi as ExtensionAPI & { registerTool?: unknown }).registerTool !== "function") return;
   let batch = 0;
   pi.registerTool({
@@ -157,34 +294,61 @@ export function registerDelegate(pi: ExtensionAPI, roles: ModelRoleManager, spaw
         const resolved = roles.resolve(role) ?? roles.resolve("default");
         const model = resolved ? `${resolved.provider}/${resolved.model}` : ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined;
         return { index: index + 1, name: cleanText(item.name ?? `agent ${index + 1}`, 24), task: item.task, role, ...(model ? { model } : {}),
-          state: "queued", tools: 0, turns: 0, cost: 0, output: "" };
+          state: "queued", tools: 0, turns: 0, cost: 0, output: "", log: [] };
       });
+      // One controller per run: aborting the tool call stops them all, the activity view stops one.
+      const controllers = runs.map(() => new AbortController());
+      const abortAll = () => { for (const controller of controllers) controller.abort(); };
+      if (signal?.aborted) abortAll(); else signal?.addEventListener("abort", abortAll, { once: true });
+      // The key doubles as the role-status id, so views can tell our own teammates from other extensions'.
+      const records: SubagentRecord[] = runs.map((run, index) => ({ key: `delegate-${id}-${run.index}`, batch: id, run, stop: () => controllers[index]!.abort(STOP_REASON) }));
+      registry.add(...records);
       const thinking = (role: string) => (roles.resolve(role) ?? roles.resolve("default"))?.thinking;
       // Live teammates: the welcome TEAM row and the footer read this public status contract.
       const publish = () => {
         if (!ctx.hasUI) return;
-        for (const run of runs) {
+        for (const { key, run } of records) {
           try {
-            ctx.ui.setStatus(`${ROLE_PREFIX}delegate-${id}-${run.index}`, run.state === "done" || run.state === "failed" ? undefined : JSON.stringify({
+            ctx.ui.setStatus(`${ROLE_PREFIX}${key}`, run.state === "done" || run.state === "failed" ? undefined : JSON.stringify({
               name: run.name, label: run.name.slice(0, 12), state: run.state === "queued" ? "waiting" : "working", task: cleanText(run.task, 60), expiresAt: Date.now() + 25_000
             }));
           } catch { /* status is decoration */ }
         }
       };
-      const details = () => ({ runs: runs.map((run) => ({ ...run })), write });
-      const update = () => {
+      // Details are persisted with the session: never the transcript, which the registry holds instead.
+      const details = (includeOutput = true) => ({ runs: runs.map(({ log: _log, ...run }) => includeOutput ? run : { ...run, output: "" }), write });
+      let updateTimer: ReturnType<typeof setTimeout> | undefined;
+      let lastUpdateAt = 0;
+      const emitUpdate = () => {
+        updateTimer = undefined;
+        lastUpdateAt = Date.now();
         publish();
-        onUpdate?.({ content: [{ type: "text", text: runs.map((run) => `${run.name}: ${run.state}`).join("\n") }], details: details() });
+        onUpdate?.({ content: [{ type: "text", text: runs.map((run) => `${run.name}: ${run.state}`).join("\n") }], details: details(false) });
+      };
+      const update = () => {
+        registry.notify();
+        if (!onUpdate) { publish(); return; }
+        const wait = Math.max(0, LIVE_UPDATE_MS - (Date.now() - lastUpdateAt));
+        if (wait === 0) { if (updateTimer) { clearTimeout(updateTimer); updateTimer = undefined; } emitUpdate(); return; }
+        if (!updateTimer) {
+          updateTimer = setTimeout(emitUpdate, wait);
+          updateTimer.unref?.();
+        }
+      };
+      const flushUpdate = () => {
+        if (updateTimer) { clearTimeout(updateTimer); updateTimer = undefined; }
+        emitUpdate();
       };
       const refresh = setInterval(publish, STATUS_REFRESH_MS);
       refresh.unref?.();
       try {
-        update();
-        await Promise.all(runs.map((run) => runDelegate(run, delegateArgs(run.task, run.model, thinking(run.role), write), ctx.cwd, signal, update, spawnProcess)));
+        await Promise.all(runs.map((run, index) => runDelegate(run, delegateArgs(run.task, run.model, thinking(run.role), write), ctx.cwd, controllers[index]!.signal, update, spawnProcess)));
       } finally {
         clearInterval(refresh);
-        for (const run of runs) if (run.state !== "done") run.state = "failed";
-        publish();
+        signal?.removeEventListener("abort", abortAll);
+        for (const run of runs) if (run.state !== "done") { run.state = "failed"; run.endedAt ??= Date.now(); }
+        registry.notify();
+        flushUpdate();
       }
       const report = runs.map((run) => `## [${run.index}] ${run.name} (${run.role}${run.model ? " · " + run.model : ""}) — ${run.state}${run.error ? ": " + run.error : ""}\n${run.output || "(no report)"}`).join("\n\n");
       return { content: [{ type: "text", text: report }], details: details() };
@@ -195,7 +359,7 @@ export function registerDelegate(pi: ExtensionAPI, roles: ModelRoleManager, spaw
         + theme.fg("dim", args.write ? " · can edit" : " · read-only"), 0, 0);
     },
     renderResult(result, { expanded }, theme) {
-      const runs = (result.details as { runs?: DelegateRun[] } | undefined)?.runs ?? [];
+      const runs = (result.details as { runs?: Array<Omit<DelegateRun, "log">> } | undefined)?.runs ?? [];
       const rows = runs.map((run) => {
         const meta = [run.role, run.activity, run.tools ? `${run.tools} tools` : "", run.cost ? `$${run.cost.toFixed(3)}` : "", run.error].filter(Boolean).join(" · ");
         let row = theme.fg(color(run.state) as never, `  ${glyph(run.state)} ${run.name}`) + theme.fg("dim", " · " + meta);

package/src/diff-view.ts

@@ -167,8 +167,8 @@ export function registerChangeReview(pi: ExtensionAPI, tracker: () => ChangeTrac
       }
     }
     if (!path) path = fallback.shift();
-    if (path) tracker()?.markDirty(path);
-    changed();
+    const failed = (event as { isError?: unknown }).isError === true;
+    if (path && !failed && tracker()?.markDirty(path)) changed();
   });
   const open = async (ctx: ExtensionContext) => {
     const current = tracker();