gsd-pi 2.81.0 → 2.82.0-dev.20138ae42

package/src/resources/extensions/gsd/native-git-bridge.ts

@@ -6,6 +6,7 @@
 // execSync calls because git2 credential handling is too complex.
 
 import { execSync, execFileSync } from "node:child_process";
+import type { ExecFileSyncOptionsWithStringEncoding } from "node:child_process";
 import { existsSync, readFileSync, unlinkSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { GSDError, GSD_GIT_ERROR } from "./errors.js";
@@ -16,6 +17,8 @@ import { isInfrastructureError } from "./auto/infra-errors.js";
 // Issue #453: keep auto-mode bookkeeping on the stable git CLI path unless a
 // caller explicitly opts into the native helper.
 const NATIVE_GSD_GIT_ENABLED = process.env.GSD_ENABLE_NATIVE_GSD_GIT === "1";
+const TRANSIENT_GIT_RETRY_CODES = new Set(["ENOBUFS", "EAGAIN"]);
+const GIT_RETRY_DELAY_MS = 200;
 
 // ─── Native Module Types ──────────────────────────────────────────────────
 
@@ -144,9 +147,46 @@ function gitExec(basePath: string, args: string[], allowFailure = false): string
       encoding: "utf-8",
       env: GIT_NO_PROMPT_ENV,
     }).trim();
-  } catch {
+  } catch (err) {
     if (allowFailure) return "";
-    throw new GSDError(GSD_GIT_ERROR, `git ${args.join(" ")} failed in ${basePath}`);
+    throw new GSDError(GSD_GIT_ERROR, `git ${args.join(" ")} failed in ${basePath}: ${getErrorMessage(err)}`);
+  }
+}
+
+/** sleepSync uses Atomics.wait for a blocking pause without busy-waiting; it blocks the current thread and requires Atomics.wait support. */
+function sleepSync(ms: number): void {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+function isRetryableGitError(err: unknown): boolean {
+  const code = isInfrastructureError(err)
+    ?? isInfrastructureError((err as { stderr?: string })?.stderr ?? "");
+  return code !== null && TRANSIENT_GIT_RETRY_CODES.has(code);
+}
+
+function execGitFileSyncWithRetry(
+  basePath: string,
+  args: string[],
+  options: Partial<ExecFileSyncOptionsWithStringEncoding>,
+): string {
+  try {
+    return execFileSync("git", args, {
+      cwd: basePath,
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf-8",
+      env: GIT_NO_PROMPT_ENV,
+      ...options,
+    }).trim();
+  } catch (err) {
+    if (!isRetryableGitError(err)) throw err;
+    sleepSync(GIT_RETRY_DELAY_MS);
+    return execFileSync("git", args, {
+      cwd: basePath,
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf-8",
+      env: GIT_NO_PROMPT_ENV,
+      ...options,
+    }).trim();
   }
 }
 
@@ -159,9 +199,9 @@ function gitFileExec(basePath: string, args: string[], allowFailure = false): st
       encoding: "utf-8",
       env: GIT_NO_PROMPT_ENV,
     }).trim();
-  } catch {
+  } catch (err) {
     if (allowFailure) return "";
-    throw new GSDError(GSD_GIT_ERROR, `git ${args.join(" ")} failed in ${basePath}`);
+    throw new GSDError(GSD_GIT_ERROR, `git ${args.join(" ")} failed in ${basePath}: ${getErrorMessage(err)}`);
   }
 }
 
@@ -428,16 +468,21 @@ export function nativeDiffNameStatus(
 
 /**
  * Get numstat diff between two refs.
+ * useMergeBase: if true, uses three-dot semantics.
  * Native: libgit2 patch line stats.
  * Fallback: `git diff --numstat`.
  */
-export function nativeDiffNumstat(basePath: string, fromRef: string, toRef: string): GitNumstat[] {
+export function nativeDiffNumstat(basePath: string, fromRef: string, toRef: string, useMergeBase?: boolean): GitNumstat[] {
   const native = loadNative();
-  if (native) {
+  if (native && !useMergeBase) {
     return native.gitDiffNumstat(basePath, fromRef, toRef);
   }
 
-  const result = gitExec(basePath, ["diff", "--numstat", fromRef, toRef], true);
+  const refspec = useMergeBase ? `${fromRef}...${toRef}` : undefined;
+  const args = refspec
+    ? ["diff", "--numstat", refspec]
+    : ["diff", "--numstat", fromRef, toRef];
+  const result = gitExec(basePath, args, true);
   if (!result) return [];
 
   return result.split("\n").filter(Boolean).map(line => {
@@ -705,20 +750,21 @@ export function nativeAddTracked(basePath: string): void {
   gitFileExec(basePath, ["add", "-u"]);
 }
 
-function isDotGsdIgnored(basePath: string): boolean {
-  for (const path of [".gsd", ".gsd/"]) {
-    try {
-      execFileSync("git", ["check-ignore", "-q", path], {
-        cwd: basePath,
-        stdio: "pipe",
-        env: GIT_NO_PROMPT_ENV,
-      });
-      return true;
-    } catch {
-      // exit 1 means this form is not ignored; try the next variant
-    }
+export function nativeIsIgnored(basePath: string, path: string): boolean {
+  try {
+    execFileSync("git", ["check-ignore", "-q", "--", path], {
+      cwd: basePath,
+      stdio: "pipe",
+      env: GIT_NO_PROMPT_ENV,
+    });
+    return true;
+  } catch {
+    return false;
   }
-  return false;
+}
+
+function isDotGsdIgnored(basePath: string): boolean {
+  return [".gsd", ".gsd/"].some(path => nativeIsIgnored(basePath, path));
 }
 
 /**
@@ -934,13 +980,10 @@ export function nativeCommit(
   try {
     const args = ["commit", "-F", "-"];
     if (options?.allowEmpty) args.push("--allow-empty");
-    const result = execFileSync("git", args, {
-      cwd: basePath,
+    const result = execGitFileSyncWithRetry(basePath, args, {
       stdio: ["pipe", "pipe", "pipe"],
-      encoding: "utf-8",
-      env: GIT_NO_PROMPT_ENV,
       input: message,
-    }).trim();
+    });
     return result;
   } catch (err: unknown) {
     const errObj = err as { stdout?: string; stderr?: string; message?: string };

package/src/resources/extensions/gsd/notification-overlay.ts

@@ -1,9 +1,8 @@
-// GSD Extension — Notification History Overlay
-// Scrollable panel showing all persisted notifications with severity filtering.
-// Toggled with Ctrl+Alt+N (⌃⌥N on macOS), Ctrl+Shift+N fallback, or /gsd notifications.
+// Project/App: GSD-2
+// File Purpose: Notification history overlay with severity filtering and width-safe TUI rendering.
 
 import type { Theme } from "@gsd/pi-coding-agent";
-import { truncateToWidth, visibleWidth, wrapTextWithAnsi, matchesKey, Key } from "@gsd/pi-tui";
+import { truncateToWidth, visibleWidth, matchesKey, Key } from "@gsd/pi-tui";
 
 import {
   readNotifications,
@@ -14,10 +13,32 @@ import {
   type NotifySeverity,
 } from "./notification-store.js";
 import { formattedShortcutPair } from "./shortcut-defs.js";
-import { padRight, joinColumns } from "../shared/mod.js";
-
-type FilterMode = "all" | "error" | "warning" | "info";
-const FILTER_CYCLE: FilterMode[] = ["all", "error", "warning", "info"];
+import {
+  padRightVisible,
+  renderFrame,
+  renderKeyHints,
+  rightAlign,
+  wrapVisibleText,
+} from "./tui/render-kit.js";
+
+type FilterMode = "all" | "error" | "warning" | "success" | "info";
+const FILTER_CYCLE: FilterMode[] = ["all", "error", "warning", "success", "info"];
+const OVERLAY_WIDTH = "58%";
+const OVERLAY_MIN_WIDTH = 68;
+const OVERLAY_MAX_HEIGHT_PERCENT = 52;
+const OVERLAY_MARGIN = { top: 2, right: 2, bottom: 6, left: 2 } as const;
+
+export function notificationOverlayOptions() {
+  return {
+    width: OVERLAY_WIDTH,
+    minWidth: OVERLAY_MIN_WIDTH,
+    maxHeight: `${OVERLAY_MAX_HEIGHT_PERCENT}%`,
+    anchor: "top-center",
+    row: "24%",
+    margin: OVERLAY_MARGIN,
+    backdrop: true,
+  } as const;
+}
 
 function severityIcon(severity: NotifySeverity): string {
   switch (severity) {
@@ -29,17 +50,6 @@ function severityIcon(severity: NotifySeverity): string {
   }
 }
 
-/** Column-aware word wrap using pi-tui's native wrapper (handles unicode/ANSI). */
-function wrapText(text: string, maxWidth: number): string[] {
-  if (maxWidth <= 0) return [text];
-  const lines = wrapTextWithAnsi(text, maxWidth);
-  // Safety clamp: if any line still exceeds maxWidth (e.g. unbreakable long token),
-  // truncate it with an ellipsis so it cannot bleed past the box border.
-  return lines.map((l) =>
-    visibleWidth(l) > maxWidth ? truncateToWidth(l, maxWidth, "…") : l,
-  );
-}
-
 function formatTimestamp(ts: string): string {
   try {
     const d = new Date(ts);
@@ -184,13 +194,19 @@ export class GSDNotificationOverlay {
     }
 
     const content = this.buildContentLines(width);
-    const maxVisibleRows = Math.max(5, process.stdout.rows ? process.stdout.rows - 8 : 24) - 2;
+    const terminalRows = process.stdout.rows || 32;
+    const availableRows = Math.max(1, terminalRows - OVERLAY_MARGIN.top - OVERLAY_MARGIN.bottom);
+    const overlayRows = Math.min(
+      availableRows,
+      Math.max(1, Math.floor((terminalRows * OVERLAY_MAX_HEIGHT_PERCENT) / 100)),
+    );
+    const maxVisibleRows = Math.max(5, overlayRows - 2);
     const visibleContentRows = Math.min(content.length, maxVisibleRows);
     const maxScroll = Math.max(0, content.length - visibleContentRows);
     this.scrollOffset = Math.min(this.scrollOffset, maxScroll);
     const visibleContent = content.slice(this.scrollOffset, this.scrollOffset + visibleContentRows);
 
-    const lines = this.wrapInBox(visibleContent, width);
+    const lines = renderFrame(this.theme, visibleContent, width);
 
     this.cachedWidth = width;
     this.cachedLines = lines;
@@ -227,33 +243,15 @@ export class GSDNotificationOverlay {
     }
   }
 
-  private wrapInBox(inner: string[], width: number): string[] {
-    const th = this.theme;
-    const border = (s: string) => th.fg("borderAccent", s);
-    const innerWidth = width - 4;
-    const lines: string[] = [];
-
-    lines.push(border("╭" + "─".repeat(width - 2) + "╮"));
-    for (const line of inner) {
-      const truncated = truncateToWidth(line, innerWidth);
-      const padWidth = Math.max(0, innerWidth - visibleWidth(truncated));
-      lines.push(border("│") + " " + truncated + " ".repeat(padWidth) + " " + border("│"));
-    }
-    lines.push(border("╰" + "─".repeat(width - 2) + "╯"));
-    return lines;
-  }
-
   private buildContentLines(width: number): string[] {
     const th = this.theme;
-    const shellWidth = width - 4;
-    const contentWidth = Math.min(shellWidth, 128);
-    const sidePad = Math.max(0, Math.floor((shellWidth - contentWidth) / 2));
-    const leftMargin = " ".repeat(sidePad);
+    const shellWidth = Math.max(1, width - 4);
+    const contentWidth = shellWidth;
     const lines: string[] = [];
 
     const row = (content = ""): string => {
       const truncated = truncateToWidth(content, contentWidth);
-      return leftMargin + padRight(truncated, contentWidth);
+      return padRightVisible(truncated, contentWidth);
     };
     const blank = () => row("");
     const hr = () => row(th.fg("dim", "─".repeat(contentWidth)));
@@ -262,9 +260,15 @@ export class GSDNotificationOverlay {
     const title = th.fg("accent", th.bold("Notifications"));
     const filterLabel = this.filter === "all"
       ? th.fg("dim", "all")
-      : th.fg(this.filter === "error" ? "error" : this.filter === "warning" ? "warning" : "dim", this.filter);
+      : th.fg(
+        this.filter === "error" ? "error"
+          : this.filter === "warning" ? "warning"
+            : this.filter === "success" ? "success"
+              : "dim",
+        this.filter,
+      );
     const count = `${this.filteredEntries.length} entries`;
-    lines.push(row(joinColumns(
+    lines.push(row(rightAlign(
       `${title}  ${th.fg("dim", "filter:")} ${filterLabel}`,
       th.fg("dim", count),
       contentWidth,
@@ -273,7 +277,7 @@ export class GSDNotificationOverlay {
 
     // Controls
     const closeShortcut = formattedShortcutPair("notifications");
-    lines.push(row(th.fg("dim", `↑/↓ scroll  f filter  c clear  Esc close  (${closeShortcut})`)));
+    lines.push(row(renderKeyHints(th, ["↑/↓ scroll", "f filter", "c clear", `Esc/${closeShortcut} close`], contentWidth)));
     lines.push(blank());
 
     // Entries
@@ -302,7 +306,7 @@ export class GSDNotificationOverlay {
       const msgMaxWidth = Math.max(10, contentWidth - prefixWidth);
 
       // Wrap long messages onto continuation lines indented to align with message start
-      const msgLines = wrapText(entry.message, msgMaxWidth);
+      const msgLines = wrapVisibleText(entry.message, msgMaxWidth);
       const indent = " ".repeat(prefixWidth);
       for (let i = 0; i < msgLines.length; i++) {
         if (i === 0) {

package/src/resources/extensions/gsd/parallel-merge.ts

@@ -8,9 +8,13 @@
 import { existsSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { spawnSync } from "node:child_process";
-import { loadFile } from "./files.js";
-import { resolveGsdPathContract, resolveMilestoneFile } from "./paths.js";
-import { mergeMilestoneToMain } from "./auto-worktree.js";
+import { resolveGsdPathContract } from "./paths.js";
+import { getAutoWorktreePath } from "./auto-worktree.js";
+import { buildWorktreeLifecycleDeps } from "./auto.js";
+import {
+  mergeMilestoneStandalone,
+  type MergeStandaloneResult,
+} from "./worktree-lifecycle.js";
 import { MergeConflictError } from "./git-service.js";
 import { removeSessionStatus } from "./session-status-io.js";
 import type { WorkerInfo } from "./parallel-orchestrator.js";
@@ -136,44 +140,46 @@ export function determineMergeOrder(
 
 /**
  * Attempt to merge a single milestone's worktree back to main.
- * Wraps mergeMilestoneToMain with error handling for parallel context.
+ *
+ * Routes through `WorktreeLifecycle.mergeMilestoneStandalone` so parallel
+ * callers get the same projection-finalize / roadmap-fallback / secondary-
+ * teardown invariants as the single-loop path. Closes the parallel-merge
+ * bypass that ADR-016 names (issue #5618).
  */
 export async function mergeCompletedMilestone(
   basePath: string,
   milestoneId: string,
 ): Promise<MergeResult> {
-  try {
-    // Load the roadmap content (needed by mergeMilestoneToMain)
-    const roadmapPath = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
-    if (!roadmapPath) {
-      return {
-        milestoneId,
-        success: false,
-        error: `No roadmap found for ${milestoneId}`,
-      };
-    }
-
-    const roadmapContent = await loadFile(roadmapPath);
-    if (!roadmapContent) {
-      return {
-        milestoneId,
-        success: false,
-        error: `Could not read roadmap for ${milestoneId}`,
-      };
-    }
+  // Resolve the worktree path explicitly; parallel-merge has no AutoSession
+  // to read it from. Only use the worktree path when git actually knows
+  // about it (`getAutoWorktreePath` returns non-null). When the directory
+  // exists on disk but isn't a registered git worktree (e.g. a stale
+  // session-status marker dir), fall back to the project root and let the
+  // standalone's mode detection pick branch-mode or skipped — using the
+  // un-registered dir as `worktreeBasePath` would cause `getCurrentBranch`
+  // to fail with a "Worktree HEAD diverged" error.
+  const registeredWtPath = getAutoWorktreePath(basePath, milestoneId);
+  const worktreeBasePath = registeredWtPath ?? basePath;
 
-    // Attempt the merge
-    const result = mergeMilestoneToMain(basePath, milestoneId, roadmapContent);
-
-    // Clean up parallel session status
-    removeSessionStatus(basePath, milestoneId);
-
-    return {
+  let result: MergeStandaloneResult;
+  try {
+    result = mergeMilestoneStandalone(buildWorktreeLifecycleDeps(), {
+      originalBasePath: basePath,
+      worktreeBasePath,
       milestoneId,
-      success: true,
-      commitMessage: result.commitMessage,
-      pushed: result.pushed,
-    };
+      // Parallel context never runs with degraded isolation — workers only
+      // exist when isolation succeeded. Pass `false` explicitly so the
+      // standalone's degraded-skip branch is not reached.
+      isolationDegraded: false,
+      notify: (msg, level) => {
+        // Surface user-visible messages from the standalone through the
+        // workflow logger so the parallel merge's progress is visible in
+        // the same channel as the rest of the parallel orchestration.
+        if (level === "error" || level === "warning") {
+          logWarning("parallel", `${milestoneId}: ${msg}`);
+        }
+      },
+    });
   } catch (err) {
     if (err instanceof MergeConflictError) {
       return {
@@ -189,6 +195,27 @@ export async function mergeCompletedMilestone(
       error: getErrorMessage(err),
     };
   }
+
+  if (!result.merged) {
+    return {
+      milestoneId,
+      success: false,
+      error:
+        result.mode === "skipped"
+          ? `Merge skipped for ${milestoneId} (mode=none or isolation degraded).`
+          : `No roadmap for ${milestoneId} — milestone branch preserved for manual merge.`,
+    };
+  }
+
+  // Clean up parallel session status — only on a real merge.
+  removeSessionStatus(basePath, milestoneId);
+
+  return {
+    milestoneId,
+    success: true,
+    commitMessage: result.commitMessage,
+    pushed: result.pushed,
+  };
 }
 
 /**

package/src/resources/extensions/gsd/parallel-monitor-overlay.ts

@@ -1,23 +1,23 @@
-/**
- * GSD Parallel Monitor Overlay
- *
- * Full-screen TUI overlay showing real-time parallel worker progress.
- * Opened via `/gsd parallel watch`, Ctrl+Alt+P (⌃⌥P on macOS),
- * or Ctrl+Shift+P fallback.
- * Reads the same data sources as `scripts/parallel-monitor.mjs` but
- * renders as a native pi-tui overlay with theme integration.
- */
+// Project/App: GSD-2
+// File Purpose: Parallel worker monitor overlay with width-safe operations-console rendering.
 
 import { existsSync, statSync, readFileSync, openSync, readSync, closeSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { spawnSync } from "node:child_process";
 
 import type { Theme } from "@gsd/pi-coding-agent";
-import { truncateToWidth, visibleWidth, matchesKey, Key } from "@gsd/pi-tui";
+import { matchesKey, Key } from "@gsd/pi-tui";
 
-import { formatDuration, STATUS_GLYPH, STATUS_COLOR } from "../shared/mod.js";
+import { formatDuration } from "../shared/mod.js";
 import { formattedShortcutPair } from "./shortcut-defs.js";
 import { resolveGsdPathContract } from "./paths.js";
+import {
+  renderBar,
+  renderKeyHints,
+  renderProgressBar,
+  safeLine,
+  statusGlyph,
+} from "./tui/render-kit.js";
 
 // ─── Types ────────────────────────────────────────────────────────────────
 
@@ -277,17 +277,6 @@ function unitTypeLabel(unitType: string | null): string {
   return labels[unitType || ""] || (unitType || "---").toUpperCase().slice(0, 5);
 }
 
-function progressBar(done: number, total: number, width: number): string {
-  if (total === 0) return "░".repeat(width);
-  const filled = Math.round((done / total) * width);
-  return "█".repeat(filled) + "░".repeat(width - filled);
-}
-
-function healthGlyph(alive: boolean, heartbeatAge: number): string {
-  if (!alive) return "○";
-  return "●";
-}
-
 // ─── Overlay Class ────────────────────────────────────────────────────────
 
 export class ParallelMonitorOverlay {
@@ -299,6 +288,7 @@ export class ParallelMonitorOverlay {
   private workers: WorkerView[] = [];
   private events: string[] = [];
   private cachedLines?: string[];
+  private cachedWidth?: number;
   private scrollOffset = 0;
   private disposed = false;
   private resizeHandler: (() => void) | null = null;
@@ -339,6 +329,7 @@ export class ParallelMonitorOverlay {
     this.events = this.events.slice(-10);
 
     this.cachedLines = undefined;
+    this.cachedWidth = undefined;
     this.tui.requestRender();
   }
 
@@ -378,14 +369,15 @@ export class ParallelMonitorOverlay {
 
   invalidate(): void {
     this.cachedLines = undefined;
+    this.cachedWidth = undefined;
   }
 
   render(width: number): string[] {
-    if (this.cachedLines) return this.cachedLines;
+    if (this.cachedLines && this.cachedWidth === width) return this.cachedLines;
 
     const t = this.theme;
     const lines: string[] = [];
-    const w = Math.max(width, 60);
+    const w = Math.max(1, width);
 
     // Header
     const totalCost = this.workers.reduce((s, wk) => s + wk.cost, 0);
@@ -398,7 +390,7 @@ export class ParallelMonitorOverlay {
       t.bold(`$${totalCost.toFixed(2)}`) +
       t.fg("muted", "  │  5s refresh"),
     );
-    lines.push(t.fg("muted", "─".repeat(w)));
+    lines.push(renderBar(t, w));
 
     if (this.workers.length === 0) {
       lines.push("");
@@ -410,7 +402,7 @@ export class ParallelMonitorOverlay {
 
         // Health + ID + state
         const healthColor = wk.alive ? "success" : "error";
-        const glyph = healthGlyph(wk.alive, wk.heartbeatAge);
+        const glyph = statusGlyph(t, wk.alive ? "active" : "idle");
         const stateText = wk.alive
           ? t.fg("success", "RUNNING")
           : t.fg("error", t.bold("DEAD"));
@@ -452,25 +444,29 @@ export class ParallelMonitorOverlay {
           lines.push(`     ${t.fg("muted", "slices")}  ${chips.join("  ")}`);
 
           // Task progress bar
-          const bar = progressBar(wk.doneTasks, wk.totalTasks, 25);
+          const barWidth = Math.max(6, Math.min(25, w - 32));
+          const bar = renderProgressBar(t, wk.doneTasks, wk.totalTasks, barWidth, {
+            filledChar: "█",
+            emptyChar: "░",
+            emptyColor: "dim",
+          });
           const pct = wk.totalTasks > 0 ? Math.round((wk.doneTasks / wk.totalTasks) * 100) : 0;
           lines.push(
-            `     ${t.fg("muted", "tasks")}   ${t.fg("success", bar)}  ${wk.doneTasks}/${wk.totalTasks} ` +
+            `     ${t.fg("muted", "tasks")}   ${bar}  ${wk.doneTasks}/${wk.totalTasks} ` +
             t.fg("muted", `(${pct}%)  │  slices done ${wk.doneSlices}/${wk.totalSlices}`),
           );
         }
 
         // Errors
         for (const err of wk.errors.slice(-2)) {
-          const truncated = err.length > w - 10 ? err.slice(0, w - 11) + "…" : err;
-          lines.push(`     ${t.fg("error", "⚠ " + truncated)}`);
+          lines.push(`     ${t.fg("error", "! " + err)}`);
         }
       }
     }
 
     // Event feed
     lines.push("");
-    lines.push(t.fg("muted", "─".repeat(w)));
+    lines.push(renderBar(t, w));
     lines.push(`  ${t.bold("Recent Events")}`);
 
     if (this.events.length === 0) {
@@ -478,8 +474,7 @@ export class ParallelMonitorOverlay {
     } else {
       for (const evt of this.events.slice(-8)) {
         const mid = evt.match(/^✓ (M\d+)\//)?.[1] || "";
-        const truncated = evt.length > w - 10 ? evt.slice(0, w - 11) + "…" : evt;
-        lines.push(`  ${t.fg("muted", "│")} ${t.fg("accent", mid)} ${truncated.replace(/^✓ M\d+\//, "")}`);
+        lines.push(`  ${t.fg("muted", "│")} ${t.fg("accent", mid)} ${evt.replace(/^✓ M\d+\//, "")}`);
       }
     }
 
@@ -496,14 +491,17 @@ export class ParallelMonitorOverlay {
       }
       lines.push(`  ${t.bold("Total: $" + this.workers.reduce((s, wk) => s + wk.cost, 0).toFixed(2))}`);
     }
-    lines.push(t.fg("muted", `  ESC/q/${formattedShortcutPair("parallel")} close  │  ↑↓ scroll`));
+    lines.push(renderKeyHints(t, [`ESC/q/${formattedShortcutPair("parallel")} close`, "↑↓ scroll"], w));
 
     // Apply scroll — use terminal rows as height estimate
     const termHeight = process.stdout.rows || 40;
     const maxScroll = Math.max(0, lines.length - termHeight);
     this.scrollOffset = Math.min(Math.max(this.scrollOffset, 0), maxScroll);
-    const visible = lines.slice(this.scrollOffset, this.scrollOffset + termHeight);
+    const visible = lines
+      .slice(this.scrollOffset, this.scrollOffset + termHeight)
+      .map((line) => safeLine(line, w));
     this.cachedLines = visible;
+    this.cachedWidth = width;
     return visible;
   }
 }