@bermudi/pi-delegate 0.1.13 → 0.1.14

package/render-branches.ts

@@ -12,10 +12,17 @@ import {
   spinnerFrame,
   formatToolCallShort,
   previewOutputLine,
+  taskTokenLabel,
   waitingLabel,
 } from "./format.ts";
-import { stripAnsi, resolveCarriageReturn } from "./utils.ts";
+import {
+  resolveCarriageReturn,
+  sanitizeTerminalLine,
+  sanitizeTerminalText,
+  stripAnsi,
+} from "./utils.ts";
 import { getMaxConcurrent } from "./config.ts";
+import { toolExpandHint } from "./key-hints.ts";
 import type { TaskProgress, TaskResult } from "./types.ts";
 
 /**
@@ -24,7 +31,7 @@ import type { TaskProgress, TaskResult } from "./types.ts";
  * so a single missing host hook cannot crash the renderer.
  */
 function renderOutputLines(raw: string, width: number): string[] {
-  const trimmed = raw.trim();
+  const trimmed = sanitizeTerminalText(raw).trim();
   if (!trimmed) return [];
   try {
     if (typeof getMarkdownTheme !== "function") return trimmed.split("\n");
@@ -59,6 +66,8 @@ export interface BranchCtx {
   ticketId?: string;
   /** Async ticket status, when known, so the renderer can show cancelling/cancelled. */
   ticketStatus?: "running" | "cancelling" | "done" | "failed" | "cancelled";
+  /** Actual batch wall time when no live render state is available. */
+  elapsedMs?: number;
 }
 
 /** Helpers shared across both branches. `pushWarnings` mutates `lines`.
@@ -77,28 +86,48 @@ export function renderPartialBranch(ctx: BranchCtx, h: RenderHelpers): void {
   const { progress, total, w, expanded, state, theme, lines } = ctx;
   const { statJoin, modelLabel, compactActivity, pushWarnings } = h;
 
-  const done = progress.filter(
+  const finished = progress.filter(
     (p) => p.status === "done" || p.status === "failed",
   ).length;
+  const failed = progress.filter((p) => p.status === "failed").length;
   const running = progress.filter((p) => p.status === "running").length;
-  const elapsed = state.startedAt
-    ? ` · ${fmtDuration(Date.now() - state.startedAt)}`
-    : "";
+  const totalTokens = progress.reduce((sum, p) => sum + p.tokens, 0);
+  const hasIncomplete = progress.some((p) => p.incomplete !== undefined);
 
-  // Richer header: agent counts + wall time. The Ctrl+O affordance is
-  // tool-scoped in Pi, so a single header hint suffices — one per running
-  // task just repeats the same line N times.
+  // Keep the live and final summaries in the same order so the header remains
+  // easy to scan as a partial result resolves into its final form.
   const headerParts: string[] = [];
-  if (ctx.ticketStatus === "cancelling") headerParts.push("CANCELLING");
   if (running > 0) headerParts.push(`${running} running`);
-  headerParts.push(`${done}/${total} done`);
-  if (!expanded && running > 0)
-    headerParts.push(theme.fg("accent", "Ctrl+O for detail"));
-  lines.push(theme.fg("muted", `${headerParts.join(" · ")}${elapsed}`), "");
+  headerParts.push(`${finished}/${total} finished`);
+  if (failed > 0) headerParts.push(`${failed} failed`);
+  headerParts.push(
+    hasIncomplete
+      ? `≥${fmtTokens(totalTokens)} tokens · incomplete accounting/evidence`
+      : `${fmtTokens(totalTokens)} tokens`,
+  );
+  if (state.startedAt)
+    headerParts.push(fmtDuration(Date.now() - state.startedAt));
+  const stateLabel =
+    ctx.ticketStatus === "cancelling"
+      ? `${theme.fg("error", "■ cancelling")} · `
+      : "";
+  const expandHint = toolExpandHint();
+  const detailHint =
+    !expanded && running > 0 && expandHint
+      ? ` · ${theme.fg("accent", expandHint)}`
+      : "";
+  lines.push(
+    `${stateLabel}${theme.fg("muted", headerParts.join(" · "))}${detailHint}`,
+    "",
+  );
 
   for (let i = 0; i < total; i++) {
     const p = progress[i]!;
     const ind = indent(i, total);
+    const agent = sanitizeTerminalLine(p.agent);
+    const task = sanitizeTerminalLine(p.task);
+    const taskId = formatTaskId(p.id);
+    const taskIdTag = taskId ? theme.fg("accent", taskId) : "";
     const runParts: string[] = [];
     if (p.toolUses > 0)
       runParts.push(`${p.toolUses} tool${p.toolUses > 1 ? "s" : ""}`);
@@ -108,18 +137,20 @@ export function renderPartialBranch(ctx: BranchCtx, h: RenderHelpers): void {
       case "done":
         lines.push(
           truncLine(
-            `${tree(i, total)} ${theme.fg("success", "✓")} ${theme.bold(p.agent)}${p.id ? theme.fg("accent", formatTaskId(p.id)) : ""}${modelLabel(p)}${statJoin([fmtDuration(p.durationMs), `${fmtTokens(p.tokens)} tokens`])}`,
+            `${tree(i, total)} ${theme.fg("success", "✓")} ${theme.bold(agent)}${taskIdTag}${theme.fg("muted", ` — ${task}`)}${expanded ? `${modelLabel(p)}${statJoin([fmtDuration(p.durationMs), taskTokenLabel(p)])}` : ""}`,
             w,
           ),
         );
         if (expanded) {
           for (const activity of p.activities.slice(-3)) {
-            const call = formatToolCallShort(activity.name, activity.args);
+            const call = sanitizeTerminalLine(
+              formatToolCallShort(activity.name, activity.args),
+            );
             const icon = activity.result?.isError
               ? theme.fg("error", "✗")
               : theme.fg("success", "✓");
             lines.push(
-              truncLine(`${ind}${theme.fg("muted", `→ ${call}`)} ${icon}`, w),
+              truncLine(`${ind}${theme.fg("dim", `→ ${call}`)} ${icon}`, w),
             );
           }
         }
@@ -127,18 +158,20 @@ export function renderPartialBranch(ctx: BranchCtx, h: RenderHelpers): void {
       case "failed":
         lines.push(
           truncLine(
-            `${tree(i, total)} ${theme.fg("error", "✗")} ${theme.bold(p.agent)}${p.id ? theme.fg("accent", formatTaskId(p.id)) : ""}${modelLabel(p)}${p.error ? theme.fg("error", ` ${p.error}`) : ""}`,
+            `${tree(i, total)} ${theme.fg("error", "✗")} ${theme.bold(agent)}${taskIdTag}${theme.fg("muted", ` — ${task}`)}${expanded ? modelLabel(p) : ""}${p.error ? theme.fg("error", ` · ${sanitizeTerminalLine(p.error)}`) : ""}`,
             w,
           ),
         );
         if (expanded) {
           for (const activity of p.activities.slice(-3)) {
-            const call = formatToolCallShort(activity.name, activity.args);
+            const call = sanitizeTerminalLine(
+              formatToolCallShort(activity.name, activity.args),
+            );
             const icon = activity.result?.isError
               ? theme.fg("error", "✗")
               : theme.fg("success", "✓");
             lines.push(
-              truncLine(`${ind}${theme.fg("muted", `→ ${call}`)} ${icon}`, w),
+              truncLine(`${ind}${theme.fg("dim", `→ ${call}`)} ${icon}`, w),
             );
           }
         }
@@ -159,7 +192,7 @@ export function renderPartialBranch(ctx: BranchCtx, h: RenderHelpers): void {
           const glyph = theme.fg("warning", spinnerFrame());
           lines.push(
             truncLine(
-              `${tree(i, total)} ${glyph} ${theme.bold(p.agent)}${p.id ? theme.fg("accent", formatTaskId(p.id)) : ""}${modelLabel(p)}${statJoin(runParts)}${issueTag}${theme.fg("muted", ageTag)}`,
+              `${tree(i, total)} ${glyph} ${theme.bold(agent)}${taskIdTag}${theme.fg("muted", ` — ${task}`)}${expanded ? `${modelLabel(p)}${statJoin(runParts)}` : ""}${issueTag}${theme.fg("dim", ageTag)}`,
               w,
             ),
           );
@@ -168,24 +201,27 @@ export function renderPartialBranch(ctx: BranchCtx, h: RenderHelpers): void {
             // ── Expanded: recent activity history (like done/failed) ──
             if (p.activities.length > 0) {
               for (const activity of p.activities.slice(-5)) {
-                const call = formatToolCallShort(activity.name, activity.args);
+                const call = sanitizeTerminalLine(
+                  formatToolCallShort(activity.name, activity.args),
+                );
                 if (!activity.result) {
                   // In-flight
                   const elapsed = ` | ${fmtDuration(Date.now() - activity.startTime)}`;
                   lines.push(
                     truncLine(
-                      `${ind}${theme.fg("warning", `> ${call}${elapsed}`)}`,
+                      `${ind}${theme.fg("warning", "›")} ${call}${theme.fg("dim", elapsed)}`,
                       w,
                     ),
                   );
                   // Show live stdout/stderr preview for streaming tools
                   if (activity.liveOutput) {
-                    const clean = stripAnsi(
-                      resolveCarriageReturn(activity.liveOutput),
+                    const clean = resolveCarriageReturn(
+                      stripAnsi(activity.liveOutput),
                     );
                     const preview = clean
                       .split("\n")
-                      .filter((l) => l.trim())
+                      .map(sanitizeTerminalLine)
+                      .filter(Boolean)
                       .slice(-3);
                     for (const outLine of preview) {
                       lines.push(
@@ -202,7 +238,7 @@ export function renderPartialBranch(ctx: BranchCtx, h: RenderHelpers): void {
                     : theme.fg("success", "✓");
                   lines.push(
                     truncLine(
-                      `${ind}${theme.fg("muted", `→ ${call}`)} ${icon}`,
+                      `${ind}${theme.fg("dim", `→ ${call}`)} ${icon}`,
                       w,
                     ),
                   );
@@ -210,16 +246,16 @@ export function renderPartialBranch(ctx: BranchCtx, h: RenderHelpers): void {
               }
             } else {
               lines.push(
-                truncLine(`${ind}${theme.fg("muted", "  thinking…")}`, w),
+                truncLine(`${ind}${theme.fg("dim", "  thinking…")}`, w),
               );
             }
           } else {
             // ── Collapsed: compact tool line with duration ─────
-            // The Ctrl+O affordance lives once in the header now — emitting
-            // it per task just repeats the same hint for every running agent.
+            // The host-configured expand affordance lives once in the header;
+            // emitting it per task repeats the hint for every running agent.
             lines.push(
               truncLine(
-                `${ind}${theme.fg("muted", `⎿  ${compactActivity(p)}`)}`,
+                `${ind}${theme.fg("warning", "›")} ${sanitizeTerminalLine(compactActivity(p))}`,
                 w,
               ),
             );
@@ -235,7 +271,7 @@ export function renderPartialBranch(ctx: BranchCtx, h: RenderHelpers): void {
         );
         lines.push(
           truncLine(
-            `${tree(i, total)} ${theme.fg("muted", "○")} ${theme.bold(p.agent)}${p.id ? theme.fg("accent", formatTaskId(p.id)) : ""}${modelLabel(p)} ${queuedTag}`,
+            `${tree(i, total)} ${theme.fg("muted", "○")} ${theme.bold(agent)}${taskIdTag}${theme.fg("muted", ` — ${task}`)}${expanded ? modelLabel(p) : ""}${queuedTag}`,
             w,
           ),
         );
@@ -245,6 +281,18 @@ export function renderPartialBranch(ctx: BranchCtx, h: RenderHelpers): void {
   }
 }
 
+function hasUserCancellationMarker(
+  progress: TaskProgress,
+  result: TaskResult | { error: string } | undefined,
+): boolean {
+  if (progress.failureKind === "cancelled") return true;
+  return (
+    result !== undefined &&
+    "failureKind" in result &&
+    result.failureKind === "cancelled"
+  );
+}
+
 /** Final (or async-ticket poll) view — static status glyphs, output previews,
  *  markdown rendering in expanded mode, and the ticket banner for live
  *  background tickets. */
@@ -259,11 +307,20 @@ export function renderFinalBranch(ctx: BranchCtx, h: RenderHelpers): void {
   // this branch must render every status. A ticket banner is shown when
   // details.ticketId is present so the human sees this is background work.
   const succeeded = progress.filter((p) => p.status === "done").length;
-  const failed = progress.filter((p) => p.status === "failed").length;
-  const finalized = succeeded + failed;
+  const cancelled = progress.filter(
+    (p, index) =>
+      p.status === "failed" && hasUserCancellationMarker(p, taskResults[index]),
+  ).length;
+  const failed = progress.filter(
+    (p, index) =>
+      p.status === "failed" &&
+      !hasUserCancellationMarker(p, taskResults[index]),
+  ).length;
+  const finalized = succeeded + failed + cancelled;
   const running = progress.filter((p) => p.status === "running").length;
   const pending = progress.filter((p) => p.status === "pending").length;
   const totalTokens = progress.reduce((sum, p) => sum + p.tokens, 0);
+  const hasIncomplete = progress.some((p) => p.incomplete !== undefined);
   const ticketId = ctx.ticketId;
   const ticketStatus = ctx.ticketStatus;
   // A terminal ticket can retain a stale running/pending row while its workers
@@ -273,29 +330,71 @@ export function renderFinalBranch(ctx: BranchCtx, h: RenderHelpers): void {
     ticketStatus === undefined ||
     ticketStatus === "running" ||
     ticketStatus === "cancelling";
-  const elapsed = state.startedAt
-    ? fmtDuration(Date.now() - state.startedAt)
-    : fmtDuration(progress.reduce((sum, p) => sum + p.durationMs, 0));
+  // Terminal tickets render stale running/pending rows with a terminal glyph.
+  // A caller-aborted task retains a structured cancellation marker after
+  // settling; count it as cancelled rather than as a generic failure. Provider
+  // failures whose human-facing text happens to be "Aborted" remain failures.
+  const terminalUnfinished = ticketIsLive ? 0 : running + pending;
+  const terminalFinalized = finalized + terminalUnfinished;
+  const terminalCancelled =
+    cancelled + (ticketStatus === "cancelled" ? terminalUnfinished : 0);
+  const terminalFailed =
+    failed + (ticketStatus === "cancelled" ? 0 : terminalUnfinished);
+  const ticketWasCancelled = ticketStatus === "cancelled";
+  let elapsed: string | undefined;
+  if (ctx.elapsedMs !== undefined) {
+    elapsed = fmtDuration(ctx.elapsedMs);
+  } else if (state.startedAt !== undefined) {
+    elapsed = fmtDuration(Date.now() - state.startedAt);
+  }
 
+  const safeTicketId = ticketId ? sanitizeTerminalLine(ticketId) : "";
+  const ticketLabel = safeTicketId ? `ticket ${safeTicketId} · ` : "";
+  const expandHint = toolExpandHint();
+  const detailHint =
+    !expanded && expandHint ? ` · ${theme.fg("accent", expandHint)}` : "";
   if (ticketId && ticketIsLive) {
     // Background ticket — frame it as in-progress, not a finished result.
-    const ticketParts = [
-      `ticket ${ticketId}`,
-      `${finalized}/${total} finalized`,
-    ];
+    const ticketParts = [`${finalized}/${total} finished`];
     if (running > 0) ticketParts.push(`${running} active`);
     if (pending > 0) ticketParts.push(`${pending} queued`);
     if (failed > 0) ticketParts.push(`${failed} failed`);
-    ticketParts.push(
-      ticketStatus === "cancelling" ? "CANCELLING" : "running in background",
+    if (cancelled > 0) ticketParts.push(`${cancelled} cancelled`);
+    const glyph =
+      ticketStatus === "cancelling"
+        ? theme.fg("error", "■")
+        : theme.fg("warning", "◐");
+    const stateLabel =
+      ticketStatus === "cancelling"
+        ? ` ${theme.fg("error", "cancelling")}`
+        : "";
+    lines.push(
+      `${glyph}${stateLabel} ${theme.fg("muted", `${ticketLabel}${ticketParts.join(" · ")}`)}${detailHint}`,
+      "",
     );
-    lines.push(theme.fg("warning", `⏳ ${ticketParts.join(" · ")}`), "");
   } else {
+    const headerParts = [`${terminalFinalized}/${total} finished`];
+    if (terminalFailed > 0) headerParts.push(`${terminalFailed} failed`);
+    if (terminalCancelled > 0)
+      headerParts.push(`${terminalCancelled} cancelled`);
+    // Cancellation is a ticket-level outcome even when every worker returned a
+    // normal terminal row. Keep it distinct from actual failed-row counts.
+    if (ticketWasCancelled) headerParts.push("ticket cancelled");
+    headerParts.push(
+      hasIncomplete
+        ? `≥${fmtTokens(totalTokens)} tokens · incomplete accounting/evidence`
+        : `${fmtTokens(totalTokens)} tokens`,
+    );
+    if (elapsed) headerParts.push(elapsed);
+    const glyph =
+      ticketStatus === "cancelled" ||
+      ticketStatus === "failed" ||
+      terminalFailed > 0 ||
+      terminalCancelled > 0
+        ? theme.fg("error", "✗")
+        : theme.fg("success", "✓");
     lines.push(
-      theme.fg(
-        "muted",
-        `${succeeded}/${total} completed · ${elapsed} wall · ${fmtTokens(totalTokens)} tokens`,
-      ),
+      `${glyph} ${theme.fg("muted", `${ticketLabel}${headerParts.join(" · ")}`)}${detailHint}`,
       "",
     );
   }
@@ -304,54 +403,70 @@ export function renderFinalBranch(ctx: BranchCtx, h: RenderHelpers): void {
     const p = progress[i]!;
     const r = taskResults[i];
     const ind = indent(i, total);
-    const isCancelledPending =
-      ticketStatus === "cancelled" && p.status === "pending";
+    const agent = sanitizeTerminalLine(p.agent);
+    const task = sanitizeTerminalLine(p.task);
+    const isTerminalUnfinished =
+      !ticketIsLive && (p.status === "running" || p.status === "pending");
+    const isCancelledUnfinished =
+      ticketStatus === "cancelled" && isTerminalUnfinished;
+    const isCancelledResult =
+      p.status === "failed" && hasUserCancellationMarker(p, r);
+    const isCancelledTask = isCancelledUnfinished || isCancelledResult;
 
-    // Unified status glyphs: ✓ done, ✗ failed, ◐ running, ○ pending.
-    // Cancelled-but-not-started tasks show as failed so they are not mistaken
-    // for still-queued work.
-    const icon = isCancelledPending
-      ? theme.fg("error", "✗")
-      : p.status === "done"
-        ? theme.fg("success", "✓")
-        : p.status === "failed"
-          ? theme.fg("error", "✗")
-          : p.status === "running"
-            ? theme.fg("warning", "◐")
-            : theme.fg("muted", "○");
-    const taskId = p.id ? formatTaskId(p.id) : "";
-    const taskIdTag = p.id ? theme.fg("accent", taskId) : "";
-    const taskIdWidth = p.id ? taskId.length : 0;
+    // Unified status glyphs: ✓ done, ✗ failed/cancelled, ◐ running, ○ pending.
+    // Terminal unfinished rows never retain a live glyph; their tail identifies
+    // cancellation separately from failure.
+    let icon: string;
+    if (isTerminalUnfinished) {
+      icon = theme.fg("error", "✗");
+    } else if (p.status === "done") {
+      icon = theme.fg("success", "✓");
+    } else if (p.status === "failed") {
+      icon = theme.fg("error", "✗");
+    } else if (p.status === "running") {
+      icon = theme.fg("warning", "◐");
+    } else {
+      icon = theme.fg("muted", "○");
+    }
+    const taskId = formatTaskId(p.id);
+    const taskIdTag = taskId ? theme.fg("accent", taskId) : "";
+    const taskIdWidth = taskId.length;
     const previewBudget = Math.max(1, w - 30 - taskIdWidth);
-    const taskPreview = theme.fg("muted", trunc(p.task, previewBudget));
+    const taskPreview = theme.fg("muted", ` — ${trunc(task, previewBudget)}`);
     const isLive =
-      ticketIsLive &&
-      (p.status === "running" ||
-        (p.status === "pending" && !isCancelledPending));
+      ticketIsLive && (p.status === "running" || p.status === "pending");
     // Live tasks show an activity/waiting hint instead of final stats.
     const liveTail =
-      p.status === "running"
-        ? theme.fg("muted", ` · ${compactActivity(p)}`)
-        : p.status === "pending" && !isCancelledPending
-          ? theme.fg("muted", ` ${waitingLabel(running, getMaxConcurrent())}`)
-          : "";
-    const cancelledTail = isCancelledPending
+      p.status === "pending"
+        ? theme.fg("muted", ` ${waitingLabel(running, getMaxConcurrent())}`)
+        : "";
+    const cancelledTail = isCancelledTask
       ? theme.fg("error", " · CANCELLED")
       : "";
     lines.push(
       truncLine(
-        `${tree(i, total)} ${icon} ${theme.bold(p.agent)}${modelLabel(p)}${taskIdTag} ${taskPreview}${isLive ? liveTail : cancelledTail || statJoin([fmtDuration(p.durationMs), `${fmtTokens(p.tokens)} tokens`])}`,
+        `${tree(i, total)} ${icon} ${theme.bold(agent)}${taskIdTag}${taskPreview}${expanded ? modelLabel(p) : ""}${isLive ? liveTail : cancelledTail || (expanded ? statJoin([fmtDuration(p.durationMs), taskTokenLabel(p)]) : "")}`,
         w,
       ),
     );
 
+    if (isLive && p.status === "running") {
+      lines.push(
+        truncLine(
+          `${ind}${theme.fg("warning", "›")} ${sanitizeTerminalLine(compactActivity(p))}`,
+          w,
+        ),
+      );
+    }
+
     // Warnings (e.g. unknown tools ignored) — muted line under the task.
     pushWarnings(p, ind);
 
     // Tool activities: compact summary only in expanded mode, terminal tasks only.
     if (p.activities.length > 0 && expanded && !isLive) {
       const names = p.activities
-        .map((a) => a.name)
+        .map((a) => sanitizeTerminalLine(a.name))
+        .filter(Boolean)
         .filter((n, i, arr) => arr.indexOf(n) === i);
       const nameList =
         names.slice(0, 4).join(", ") +
@@ -366,17 +481,31 @@ export function renderFinalBranch(ctx: BranchCtx, h: RenderHelpers): void {
       const status = statusParts.length ? ` · ${statusParts.join(", ")}` : "";
       lines.push(
         truncLine(
-          `${ind}${theme.fg("muted", `${p.activities.length} tool${p.activities.length > 1 ? "s" : ""}: ${nameList}${status}`)}`,
+          `${ind}${theme.fg("dim", `${p.activities.length} tool${p.activities.length > 1 ? "s" : ""}: ${nameList}${status}`)}`,
+          w,
+        ),
+      );
+    }
+
+    if (
+      !isLive &&
+      ((r && "incomplete" in r && r.incomplete === "quiescence_abandoned") ||
+        p.incomplete === "quiescence_abandoned")
+    ) {
+      lines.push(
+        truncLine(
+          `${ind}${theme.fg("warning", "INCOMPLETE: accounting and output/file evidence are lower bounds; session quarantined")}`,
           w,
         ),
       );
     }
 
     // Surface errors even when output exists (agent may have emitted text before failing).
-    // Live tasks and cancelled-but-not-started tasks already show their status
-    // on the row, so don't duplicate it as an error line.
-    if (!isLive && !isCancelledPending && r && "error" in r && r.error) {
-      lines.push(truncLine(`${ind}${theme.fg("error", r.error)}`, w));
+    // Live and cancelled tasks already show their status on the row, so don't
+    // duplicate it as an error line.
+    if (!isLive && !isCancelledTask && r && "error" in r && r.error) {
+      const error = sanitizeTerminalLine(r.error);
+      if (error) lines.push(truncLine(`${ind}${theme.fg("error", error)}`, w));
     }
     if (r && "integration" in r && r.integration) {
       const integration = r.integration;
@@ -395,17 +524,33 @@ export function renderFinalBranch(ctx: BranchCtx, h: RenderHelpers): void {
         if (integration.patchPath)
           lines.push(
             truncLine(
-              `${ind}${theme.fg("muted", `patch: ${integration.patchPath}`)}`,
+              `${ind}${theme.fg("dim", `patch: ${sanitizeTerminalLine(integration.patchPath)}`)}`,
               w,
             ),
           );
         if (integration.worktreePath)
           lines.push(
             truncLine(
-              `${ind}${theme.fg("muted", `worktree: ${integration.worktreePath}`)}`,
+              `${ind}${theme.fg("dim", `worktree: ${sanitizeTerminalLine(integration.worktreePath)}`)}`,
+              w,
+            ),
+          );
+        if (integration.cleanupIssue) {
+          lines.push(
+            truncLine(
+              `${ind}${theme.fg("error", `cleanup ${integration.cleanupIssue.status}: ${sanitizeTerminalLine(integration.cleanupIssue.reason)}`)}`,
               w,
             ),
           );
+          if (integration.cleanupIssue.recoveryPath) {
+            lines.push(
+              truncLine(
+                `${ind}${theme.fg("dim", `cleanup recovery: ${sanitizeTerminalLine(integration.cleanupIssue.recoveryPath)}`)}`,
+                w,
+              ),
+            );
+          }
+        }
       }
     }
     // Collapsed: one-line output preview so a human scanning the TUI sees
@@ -417,7 +562,9 @@ export function renderFinalBranch(ctx: BranchCtx, h: RenderHelpers): void {
           ? previewOutputLine(r.output ?? "", w - ind.length - 3)
           : "";
       if (preview) {
-        lines.push(truncLine(`${ind}${theme.fg("muted", `⎿ ${preview}`)}`, w));
+        lines.push(
+          truncLine(`${ind}${theme.fg("success", "⎿")} ${preview}`, w),
+        );
       }
     }
     // Output: render markdown only in expanded mode.