gsd-pi 2.81.0 → 2.82.0-dev.20138ae42

package/dist/resources/extensions/gsd/migrate/writer.js

@@ -296,7 +296,17 @@ export function formatProject(content) {
  */
 export function formatDecisions(content) {
     if (!content || !content.trim()) {
-        return '# Decisions\n\n<!-- Append-only register of architectural and pattern decisions -->\n\n| ID | Decision | Rationale | Date |\n|----|----------|-----------|------|\n';
+        return [
+            '# Decisions Register',
+            '',
+            '<!-- Append-only. Never edit or remove existing rows.',
+            '     To reverse a decision, add a new row that supersedes it.',
+            '     Read this file at the start of any planning or research phase. -->',
+            '',
+            '| # | When | Scope | Decision | Choice | Rationale | Revisable? | Made By |',
+            '|---|------|-------|----------|--------|-----------|------------|---------|',
+            '',
+        ].join('\n');
     }
     return content.endsWith('\n') ? content : content + '\n';
 }

package/dist/resources/extensions/gsd/migration-auto-check.js

@@ -1,10 +1,8 @@
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { ensureDbOpen } from "./bootstrap/dynamic-tools.js";
-import { clearEngineHierarchy, getAllMilestones, getMilestoneSlices, getSliceTasks, isDbAvailable, transaction, } from "./gsd-db.js";
-import { migrateHierarchyToDb } from "./md-importer.js";
+import { getAllMilestones, getMilestoneSlices, getSliceTasks, isDbAvailable, } from "./gsd-db.js";
 import { parsePlan, parseRoadmap } from "./parsers-legacy.js";
 import { milestonesDir, resolveMilestoneFile, resolveSliceFile, } from "./paths.js";
-import { invalidateStateCache } from "./state.js";
 function zeroCounts() {
     return { milestones: 0, slices: 0, tasks: 0 };
 }
@@ -50,7 +48,7 @@ export function countDbHierarchy() {
     }
     return counts;
 }
-export async function autoImportMarkdownHierarchyIfDbMismatch(basePath) {
+export async function checkMarkdownHierarchyAgainstDb(basePath) {
     const markdown = countMarkdownHierarchy(basePath);
     if (sameCounts(markdown, zeroCounts())) {
         return {
@@ -70,18 +68,15 @@ export async function autoImportMarkdownHierarchyIfDbMismatch(basePath) {
         return { action: "none", reason: "in-sync", markdown, beforeDb, afterDb: beforeDb };
     }
     const reason = sameCounts(beforeDb, zeroCounts()) ? "db-empty" : "count-mismatch";
-    const imported = transaction(() => {
-        clearEngineHierarchy();
-        return migrateHierarchyToDb(basePath);
-    });
-    invalidateStateCache();
-    const afterDb = {
-        milestones: imported.milestones,
-        slices: imported.slices,
-        tasks: imported.tasks,
+    return {
+        action: "recovery-required",
+        reason,
+        markdown,
+        beforeDb,
+        afterDb: beforeDb,
+        recoveryCommand: "gsd recover",
+        message: `Markdown planning artifacts (${markdown.milestones}M/${markdown.slices}S/${markdown.tasks}T) ` +
+            `do not match the authoritative DB (${beforeDb.milestones}M/${beforeDb.slices}S/${beforeDb.tasks}T). ` +
+            "Runtime startup will not import markdown automatically; run explicit GSD recovery if markdown should repopulate the database.",
     };
-    if (!sameCounts(markdown, afterDb)) {
-        throw new Error(`migration auto-import verification failed: markdown ${markdown.milestones}M/${markdown.slices}S/${markdown.tasks}T, db ${afterDb.milestones}M/${afterDb.slices}S/${afterDb.tasks}T`);
-    }
-    return { action: "imported", reason, markdown, beforeDb, afterDb };
 }

package/dist/resources/extensions/gsd/milestone-actions.js

@@ -19,6 +19,7 @@ import { deleteMilestone, getMilestone, isDbAvailable, updateMilestoneStatus } f
 import { removeWorktree } from "./worktree-manager.js";
 import { logWarning } from "./workflow-logger.js";
 import { isAutoActive } from "./auto.js";
+import { isClosedStatus } from "./status-guards.js";
 /**
  * Writer-side assert for mutations that race with auto-mode's squash merge (#4704).
  * Auto-mode is confirmed not to call parkMilestone/discardMilestone/unparkMilestone
@@ -34,7 +35,7 @@ function assertNotAutoActive(action) {
 /**
  * Park a milestone — creates a PARKED.md marker file with reason and timestamp.
  * Parked milestones are skipped during active-milestone discovery but stay on disk.
- * Returns true if successfully parked, false if milestone not found or already parked.
+ * Returns true if successfully parked, false if milestone not found, already parked, or complete.
  */
 export function parkMilestone(basePath, milestoneId, reason) {
     assertNotAutoActive("park milestone");
@@ -42,9 +43,15 @@ export function parkMilestone(basePath, milestoneId, reason) {
     if (!mDir || !existsSync(mDir))
         return false;
     // Guard: do not park a completed milestone — it would corrupt depends_on satisfaction
-    const summaryFile = resolveMilestoneFile(basePath, milestoneId, "SUMMARY");
-    if (summaryFile)
+    const dbAvailable = isDbAvailable();
+    const milestone = dbAvailable ? getMilestone(milestoneId) : null;
+    if (milestone && isClosedStatus(milestone.status))
         return false;
+    if (!dbAvailable) {
+        const summaryFile = resolveMilestoneFile(basePath, milestoneId, "SUMMARY");
+        if (summaryFile)
+            return false;
+    }
     const parkedPath = join(mDir, buildMilestoneFileName(milestoneId, "PARKED"));
     if (existsSync(parkedPath))
         return false; // already parked
@@ -61,7 +68,7 @@ export function parkMilestone(basePath, milestoneId, reason) {
     ].join("\n");
     writeFileSync(parkedPath, content, "utf-8");
     // Sync DB status so deriveStateFromDb also skips this milestone (#2694)
-    if (isDbAvailable()) {
+    if (dbAvailable) {
         try {
             updateMilestoneStatus(milestoneId, "parked");
         }

package/dist/resources/extensions/gsd/native-git-bridge.js

@@ -14,6 +14,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 Loading ──────────────────────────────────────────────────
 let nativeModule = null;
 let loadAttempted = false;
@@ -46,10 +48,42 @@ function gitExec(basePath, args, allowFailure = false) {
             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) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function isRetryableGitError(err) {
+    const code = isInfrastructureError(err)
+        ?? isInfrastructureError(err?.stderr ?? "");
+    return code !== null && TRANSIENT_GIT_RETRY_CODES.has(code);
+}
+function execGitFileSyncWithRetry(basePath, args, options) {
+    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();
     }
 }
 /** Run a git command via execFileSync. Returns trimmed stdout. */
@@ -62,10 +96,10 @@ function gitFileExec(basePath, args, allowFailure = false) {
             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)}`);
     }
 }
 // ─── Existing Read Functions ──────────────────────────────────────────────
@@ -303,15 +337,20 @@ export function nativeDiffNameStatus(basePath, fromRef, toRef, pathspec, useMerg
 }
 /**
  * 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, fromRef, toRef) {
+export function nativeDiffNumstat(basePath, fromRef, toRef, useMergeBase) {
     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 => {
@@ -551,21 +590,21 @@ export function nativeAddAll(basePath) {
 export function nativeAddTracked(basePath) {
     gitFileExec(basePath, ["add", "-u"]);
 }
-function isDotGsdIgnored(basePath) {
-    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, path) {
+    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) {
+    return [".gsd", ".gsd/"].some(path => nativeIsIgnored(basePath, path));
 }
 /**
  * Determine whether the project opts out of GSD-managed `.gitignore` via
@@ -777,13 +816,10 @@ export function nativeCommit(basePath, message, options) {
         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) {

package/dist/resources/extensions/gsd/notification-overlay.js

@@ -1,11 +1,25 @@
-// 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.
-import { truncateToWidth, visibleWidth, wrapTextWithAnsi, matchesKey, Key } from "@gsd/pi-tui";
+// Project/App: GSD-2
+// File Purpose: Notification history overlay with severity filtering and width-safe TUI rendering.
+import { truncateToWidth, visibleWidth, matchesKey, Key } from "@gsd/pi-tui";
 import { readNotifications, markAllRead, clearNotifications, onNotificationStoreChange, } from "./notification-store.js";
 import { formattedShortcutPair } from "./shortcut-defs.js";
-import { padRight, joinColumns } from "../shared/mod.js";
-const FILTER_CYCLE = ["all", "error", "warning", "info"];
+import { padRightVisible, renderFrame, renderKeyHints, rightAlign, wrapVisibleText, } from "./tui/render-kit.js";
+const FILTER_CYCLE = ["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 };
+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,
+    };
+}
 function severityIcon(severity) {
     switch (severity) {
         case "error": return "✗";
@@ -15,15 +29,6 @@ function severityIcon(severity) {
         default: return "●";
     }
 }
-/** Column-aware word wrap using pi-tui's native wrapper (handles unicode/ANSI). */
-function wrapText(text, maxWidth) {
-    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) {
     try {
         const d = new Date(ts);
@@ -155,12 +160,15 @@ export class GSDNotificationOverlay {
             return this.cachedLines;
         }
         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;
         return lines;
@@ -192,30 +200,14 @@ export class GSDNotificationOverlay {
             this.tui.requestRender();
         }
     }
-    wrapInBox(inner, width) {
-        const th = this.theme;
-        const border = (s) => th.fg("borderAccent", s);
-        const innerWidth = width - 4;
-        const lines = [];
-        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;
-    }
     buildContentLines(width) {
         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 = [];
         const row = (content = "") => {
             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)));
@@ -223,13 +215,16 @@ 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(`${title}  ${th.fg("dim", "filter:")} ${filterLabel}`, th.fg("dim", count), contentWidth)));
+        lines.push(row(rightAlign(`${title}  ${th.fg("dim", "filter:")} ${filterLabel}`, th.fg("dim", count), contentWidth)));
         lines.push(hr());
         // 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
         const filtered = this.filteredEntries;
@@ -254,7 +249,7 @@ export class GSDNotificationOverlay {
             const prefixWidth = visibleWidth(prefix);
             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/dist/resources/extensions/gsd/parallel-merge.js

@@ -7,9 +7,10 @@
 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, } from "./worktree-lifecycle.js";
 import { MergeConflictError } from "./git-service.js";
 import { removeSessionStatus } from "./session-status-io.js";
 import { getErrorMessage } from "./error-utils.js";
@@ -105,37 +106,42 @@ export function determineMergeOrder(workers, order = "sequential", basePath) {
 }
 /**
  * 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, 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;
+    let result;
     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}`,
-            };
-        }
-        // Attempt the merge
-        const result = mergeMilestoneToMain(basePath, milestoneId, roadmapContent);
-        // Clean up parallel session status
-        removeSessionStatus(basePath, milestoneId);
-        return {
+        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) {
@@ -152,6 +158,23 @@ export async function mergeCompletedMilestone(basePath, milestoneId) {
             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,
+    };
 }
 /**
  * Merge all completed milestones in sequence.

package/dist/resources/extensions/gsd/parallel-monitor-overlay.js

@@ -1,12 +1,5 @@
-/**
- * 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";
@@ -14,6 +7,7 @@ import { matchesKey, Key } from "@gsd/pi-tui";
 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";
 // ─── Data Helpers ─────────────────────────────────────────────────────────
 function readJsonSafe(filePath) {
     try {
@@ -226,17 +220,6 @@ function unitTypeLabel(unitType) {
     };
     return labels[unitType || ""] || (unitType || "---").toUpperCase().slice(0, 5);
 }
-function progressBar(done, total, width) {
-    if (total === 0)
-        return "░".repeat(width);
-    const filled = Math.round((done / total) * width);
-    return "█".repeat(filled) + "░".repeat(width - filled);
-}
-function healthGlyph(alive, heartbeatAge) {
-    if (!alive)
-        return "○";
-    return "●";
-}
 // ─── Overlay Class ────────────────────────────────────────────────────────
 export class ParallelMonitorOverlay {
     tui;
@@ -247,6 +230,7 @@ export class ParallelMonitorOverlay {
     workers = [];
     events = [];
     cachedLines;
+    cachedWidth;
     scrollOffset = 0;
     disposed = false;
     resizeHandler = null;
@@ -279,6 +263,7 @@ export class ParallelMonitorOverlay {
         }
         this.events = this.events.slice(-10);
         this.cachedLines = undefined;
+        this.cachedWidth = undefined;
         this.tui.requestRender();
     }
     dispose() {
@@ -313,13 +298,14 @@ export class ParallelMonitorOverlay {
     }
     invalidate() {
         this.cachedLines = undefined;
+        this.cachedWidth = undefined;
     }
     render(width) {
-        if (this.cachedLines)
+        if (this.cachedLines && this.cachedWidth === width)
             return this.cachedLines;
         const t = this.theme;
         const lines = [];
-        const w = Math.max(width, 60);
+        const w = Math.max(1, width);
         // Header
         const totalCost = this.workers.reduce((s, wk) => s + wk.cost, 0);
         const aliveCount = this.workers.filter((wk) => wk.alive).length;
@@ -328,7 +314,7 @@ export class ParallelMonitorOverlay {
         lines.push(t.fg("muted", `  ${now}  │  ${aliveCount}/${this.workers.length} alive  │  Total: `) +
             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("");
             lines.push(t.fg("warning", "  No parallel workers found."));
@@ -339,7 +325,7 @@ export class ParallelMonitorOverlay {
                 lines.push("");
                 // 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"));
@@ -374,21 +360,25 @@ 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} ` +
+                    lines.push(`     ${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) {
             lines.push(t.fg("muted", "  No events yet..."));
@@ -396,8 +386,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+\//, "")}`);
             }
         }
         // Footer
@@ -411,13 +400,16 @@ 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;
     }
 }