gsd-pi 2.54.0 → 2.55.0-dev.9ec7cdf

package/dist/resources/extensions/gsd/auto-worktree.js

@@ -22,6 +22,8 @@ import { logWarning } from "./workflow-logger.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { nativeGetCurrentBranch, nativeDetectMainBranch, nativeWorkingTreeStatus, nativeAddAllWithExclusions, nativeCommit, nativeCheckoutBranch, nativeMergeSquash, nativeConflictFiles, nativeCheckoutTheirs, nativeAddPaths, nativeRmForce, nativeBranchDelete, nativeBranchExists, nativeDiffNumstat, nativeUpdateRef, nativeIsAncestor, } from "./native-git-bridge.js";
 const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
+const PROJECT_PREFERENCES_FILE = "PREFERENCES.md";
+const LEGACY_PROJECT_PREFERENCES_FILE = "preferences.md";
 // ─── Shared Constants & Helpers ─────────────────────────────────────────────
 /**
  * Root-level .gsd/ state files synced between worktree and project root.
@@ -37,7 +39,7 @@ const ROOT_STATE_FILES = [
     "QUEUE.md",
     "completed-units.json",
     "metrics.json",
-    // NOTE: preferences.md is intentionally NOT in ROOT_STATE_FILES.
+    // NOTE: project preferences are intentionally NOT in ROOT_STATE_FILES.
     // Forward-sync (main → worktree) is handled explicitly in syncGsdStateToWorktree().
     // Back-sync (worktree → main) must NEVER overwrite the project root's copy
     // because the project root is authoritative for preferences (#2684).
@@ -134,6 +136,11 @@ export function syncProjectRootToWorktree(projectRoot, worktreePath_, milestoneI
         return;
     const prGsd = join(projectRoot, ".gsd");
     const wtGsd = join(worktreePath_, ".gsd");
+    // When .gsd is a symlink to the same external directory in both locations,
+    // cpSync rejects the copy because source === destination (ERR_FS_CP_EINVAL).
+    // Compare realpaths and skip when they resolve to the same physical path (#2184).
+    if (isSamePath(prGsd, wtGsd))
+        return;
     // Copy milestone directory from project root to worktree — additive only.
     // force:false prevents cpSync from overwriting existing worktree files.
     // Without this, worktree-authoritative files (e.g. VALIDATION.md written
@@ -169,6 +176,11 @@ export function syncStateToProjectRoot(worktreePath_, projectRoot, milestoneId)
         return;
     const wtGsd = join(worktreePath_, ".gsd");
     const prGsd = join(projectRoot, ".gsd");
+    // When .gsd is a symlink to the same external directory in both locations,
+    // cpSync rejects the copy because source === destination (ERR_FS_CP_EINVAL).
+    // Compare realpaths and skip when they resolve to the same physical path (#2184).
+    if (isSamePath(wtGsd, prGsd))
+        return;
     // 1. STATE.md — the quick-glance status used by initial deriveState()
     safeCopy(join(wtGsd, "STATE.md"), join(prGsd, "STATE.md"), { force: true });
     // 2. Milestone directory — ROADMAP, slice PLANs, task summaries
@@ -338,19 +350,26 @@ export function syncGsdStateToWorktree(mainBasePath, worktreePath_) {
             }
         }
     }
-    // Forward-sync preferences.md from project root to worktree (additive only).
-    // NOT in ROOT_STATE_FILES because syncWorktreeStateBack() must never overwrite
-    // the project root's preferences — the project root is authoritative (#2684).
+    // Forward-sync project preferences from project root to worktree (additive only).
+    // Prefer the canonical uppercase file name, but keep the legacy lowercase
+    // fallback so older repos still work on case-sensitive filesystems.
     {
-        const src = join(mainGsd, "preferences.md");
-        const dst = join(wtGsd, "preferences.md");
-        if (existsSync(src) && !existsSync(dst)) {
-            try {
-                cpSync(src, dst);
-                synced.push("preferences.md");
-            }
-            catch {
-                /* non-fatal */
+        const worktreeHasPreferences = existsSync(join(wtGsd, PROJECT_PREFERENCES_FILE))
+            || existsSync(join(wtGsd, LEGACY_PROJECT_PREFERENCES_FILE));
+        if (!worktreeHasPreferences) {
+            for (const file of [PROJECT_PREFERENCES_FILE, LEGACY_PROJECT_PREFERENCES_FILE]) {
+                const src = join(mainGsd, file);
+                const dst = join(wtGsd, file);
+                if (existsSync(src)) {
+                    try {
+                        cpSync(src, dst);
+                        synced.push(file);
+                    }
+                    catch {
+                        /* non-fatal */
+                    }
+                    break;
+                }
             }
         }
     }
@@ -836,10 +855,16 @@ function copyPlanningArtifacts(srcBase, wtPath) {
         "STATE.md",
         "KNOWLEDGE.md",
         "OVERRIDES.md",
-        "preferences.md",
     ]) {
         safeCopy(join(srcGsd, file), join(dstGsd, file), { force: true });
     }
+    // Seed canonical PREFERENCES.md when available; fall back to legacy lowercase.
+    if (existsSync(join(srcGsd, PROJECT_PREFERENCES_FILE))) {
+        safeCopy(join(srcGsd, PROJECT_PREFERENCES_FILE), join(dstGsd, PROJECT_PREFERENCES_FILE), { force: true });
+    }
+    else if (existsSync(join(srcGsd, LEGACY_PROJECT_PREFERENCES_FILE))) {
+        safeCopy(join(srcGsd, LEGACY_PROJECT_PREFERENCES_FILE), join(dstGsd, LEGACY_PROJECT_PREFERENCES_FILE), { force: true });
+    }
     // Shared WAL (R012): worktrees use the project root's DB directly.
     // No longer copy gsd.db into the worktree — the DB path resolver in
     // ensureDbOpen() detects the worktree location and opens the root DB.

package/dist/resources/extensions/gsd/bootstrap/agent-end-recovery.js

@@ -5,6 +5,7 @@ import { pauseAutoForProviderError } from "../provider-error-pause.js";
 import { isSessionSwitchInFlight, resolveAgentEnd } from "../auto-loop.js";
 import { resolveModelId } from "../auto-model-selection.js";
 import { clearDiscussionFlowState } from "./write-gate.js";
+import { resumeAutoAfterProviderDelay } from "./provider-error-resume.js";
 import { classifyError, createRetryState, resetRetryState, isTransient, } from "../error-classifier.js";
 const retryState = createRetryState();
 const MAX_NETWORK_RETRIES = 2;
@@ -28,7 +29,10 @@ async function pauseTransientWithBackoff(cls, pi, ctx, errorDetail, isRateLimit)
         retryAfterMs,
         resume: allowAutoResume
             ? () => {
-                pi.sendMessage({ customType: "gsd-auto-timeout-recovery", content: "Continue execution — provider error recovery delay elapsed.", display: false }, { triggerTurn: true });
+                void resumeAutoAfterProviderDelay(pi, ctx).catch((err) => {
+                    const message = err instanceof Error ? err.message : String(err);
+                    ctx.ui.notify(`Provider error recovery delay elapsed, but auto-mode failed to resume: ${message}`, "error");
+                });
             }
             : undefined,
     });

package/dist/resources/extensions/gsd/bootstrap/provider-error-resume.js

@@ -0,0 +1,18 @@
+import { getAutoDashboardData, startAuto } from "../auto.js";
+const defaultDeps = {
+    getSnapshot: () => getAutoDashboardData(),
+    startAuto,
+};
+export async function resumeAutoAfterProviderDelay(pi, ctx, deps = defaultDeps) {
+    const snapshot = deps.getSnapshot();
+    if (snapshot.active)
+        return "already-active";
+    if (!snapshot.paused)
+        return "not-paused";
+    if (!snapshot.basePath) {
+        ctx.ui.notify("Provider error recovery delay elapsed, but no paused auto-mode base path was available. Leaving auto-mode paused.", "warning");
+        return "missing-base";
+    }
+    await deps.startAuto(ctx, pi, snapshot.basePath, false, { step: snapshot.stepMode });
+    return "resumed";
+}

package/dist/resources/extensions/gsd/bootstrap/register-extension.js

@@ -6,14 +6,27 @@ import { registerDynamicTools } from "./dynamic-tools.js";
 import { registerJournalTools } from "./journal-tools.js";
 import { registerHooks } from "./register-hooks.js";
 import { registerShortcuts } from "./register-shortcuts.js";
+export function handleRecoverableExtensionProcessError(err) {
+    if (err.code === "EPIPE") {
+        process.exit(0);
+    }
+    if (err.code === "ENOENT") {
+        const syscall = err.syscall;
+        if (syscall?.startsWith("spawn")) {
+            process.stderr.write(`[gsd] spawn ENOENT: ${err.path ?? "unknown"} — command not found\n`);
+            return true;
+        }
+        if (syscall === "uv_cwd") {
+            process.stderr.write(`[gsd] ENOENT (${syscall}): ${err.message}\n`);
+            return true;
+        }
+    }
+    return false;
+}
 function installEpipeGuard() {
     if (!process.listeners("uncaughtException").some((listener) => listener.name === "_gsdEpipeGuard")) {
         const _gsdEpipeGuard = (err) => {
-            if (err.code === "EPIPE") {
-                process.exit(0);
-            }
-            if (err.code === "ENOENT" && err.syscall?.startsWith("spawn")) {
-                process.stderr.write(`[gsd] spawn ENOENT: ${err.path ?? "unknown"} — command not found\n`);
+            if (handleRecoverableExtensionProcessError(err)) {
                 return;
             }
             throw err;

package/dist/resources/extensions/gsd/bootstrap/register-shortcuts.js

@@ -2,6 +2,7 @@ import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { Key } from "@gsd/pi-tui";
 import { GSDDashboardOverlay } from "../dashboard-overlay.js";
+import { ParallelMonitorOverlay } from "../parallel-monitor-overlay.js";
 import { shortcutDesc } from "../../shared/mod.js";
 export function registerShortcuts(pi) {
     pi.registerShortcut(Key.ctrlAlt("g"), {
@@ -22,4 +23,23 @@ export function registerShortcuts(pi) {
             });
         },
     });
+    pi.registerShortcut(Key.ctrlAlt("p"), {
+        description: shortcutDesc("Open parallel worker monitor", "/gsd parallel watch"),
+        handler: async (ctx) => {
+            const parallelDir = join(process.cwd(), ".gsd", "parallel");
+            if (!existsSync(parallelDir)) {
+                ctx.ui.notify("No parallel workers found. Run /gsd parallel start first.", "info");
+                return;
+            }
+            await ctx.ui.custom((tui, theme, _kb, done) => new ParallelMonitorOverlay(tui, theme, () => done()), {
+                overlay: true,
+                overlayOptions: {
+                    width: "90%",
+                    minWidth: 80,
+                    maxHeight: "92%",
+                    anchor: "center",
+                },
+            });
+        },
+    });
 }

package/dist/resources/extensions/gsd/commands/catalog.js

@@ -47,7 +47,7 @@ export const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "inspect", desc: "Show SQLite DB diagnostics" },
     { cmd: "knowledge", desc: "Add persistent project knowledge (rule, pattern, or lesson)" },
     { cmd: "new-milestone", desc: "Create a milestone from a specification document (headless)" },
-    { cmd: "parallel", desc: "Parallel milestone orchestration (start, status, stop, merge)" },
+    { cmd: "parallel", desc: "Parallel milestone orchestration (start, status, stop, merge, watch)" },
     { cmd: "cmux", desc: "Manage cmux integration (status, sidebar, notifications, splits)" },
     { cmd: "park", desc: "Park a milestone — skip without deleting" },
     { cmd: "unpark", desc: "Reactivate a parked milestone" },
@@ -87,6 +87,7 @@ const NESTED_COMPLETIONS = {
         { cmd: "pause", desc: "Pause a specific worker" },
         { cmd: "resume", desc: "Resume a paused worker" },
         { cmd: "merge", desc: "Merge completed milestone branches" },
+        { cmd: "watch", desc: "Live TUI dashboard monitoring all workers" },
     ],
     setup: [
         { cmd: "llm", desc: "Configure LLM provider settings" },

package/dist/resources/extensions/gsd/commands/handlers/parallel.js

@@ -87,6 +87,20 @@ export async function handleParallelCommand(trimmed, _ctx, pi) {
         emitParallelMessage(pi, formatMergeResults(results));
         return true;
     }
-    emitParallelMessage(pi, `Unknown parallel subcommand "${subcommand}". Usage: /gsd parallel [start|status|stop|pause|resume|merge]`);
+    if (subcommand === "watch") {
+        const root = projectRoot();
+        const { ParallelMonitorOverlay } = await import("../../parallel-monitor-overlay.js");
+        await _ctx.ui.custom((tui, theme, _kb, done) => new ParallelMonitorOverlay(tui, theme, () => done(), root), {
+            overlay: true,
+            overlayOptions: {
+                width: "90%",
+                minWidth: 80,
+                maxHeight: "92%",
+                anchor: "center",
+            },
+        });
+        return true;
+    }
+    emitParallelMessage(pi, `Unknown parallel subcommand "${subcommand}". Usage: /gsd parallel [start|status|stop|pause|resume|merge|watch]`);
     return true;
 }

package/dist/resources/extensions/gsd/crash-recovery.js

@@ -13,9 +13,9 @@ import { readFileSync, unlinkSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import { gsdRoot } from "./paths.js";
 import { atomicWriteSync } from "./atomic-write.js";
-const LOCK_FILE = "auto.lock";
+import { effectiveLockFile } from "./session-lock.js";
 function lockPath(basePath) {
-    return join(gsdRoot(basePath), LOCK_FILE);
+    return join(gsdRoot(basePath), effectiveLockFile());
 }
 /** Write or update the lock file with current auto-mode state. */
 export function writeLock(basePath, unitType, unitId, sessionFile) {

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

@@ -0,0 +1,413 @@
+/**
+ * GSD Parallel Monitor Overlay
+ *
+ * Full-screen TUI overlay showing real-time parallel worker progress.
+ * Opened via `/gsd parallel watch` or Ctrl+Alt+P.
+ * Reads the same data sources as `scripts/parallel-monitor.mjs` but
+ * renders as a native pi-tui overlay with theme integration.
+ */
+import { existsSync, statSync, readFileSync, openSync, readSync, closeSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+import { matchesKey, Key } from "@gsd/pi-tui";
+import { formatDuration } from "../shared/mod.js";
+// ─── Data Helpers ─────────────────────────────────────────────────────────
+function readJsonSafe(filePath) {
+    try {
+        return JSON.parse(readFileSync(filePath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function tailRead(filePath, maxBytes) {
+    try {
+        const stat = statSync(filePath);
+        const readSize = Math.min(stat.size, maxBytes);
+        const fd = openSync(filePath, "r");
+        const buf = Buffer.alloc(readSize);
+        readSync(fd, buf, 0, readSize, Math.max(0, stat.size - readSize));
+        closeSync(fd);
+        return buf.toString("utf-8");
+    }
+    catch {
+        return "";
+    }
+}
+function discoverWorkers(basePath) {
+    const parallelDir = join(basePath, ".gsd", "parallel");
+    const worktreeDir = join(basePath, ".gsd", "worktrees");
+    const mids = new Set();
+    if (existsSync(parallelDir)) {
+        try {
+            for (const f of readdirSync(parallelDir)) {
+                if (f.endsWith(".status.json"))
+                    mids.add(f.replace(".status.json", ""));
+                const m = f.match(/^(M\d+)\.(stderr|stdout)\.log$/);
+                if (m)
+                    mids.add(m[1]);
+            }
+        }
+        catch { /* skip */ }
+    }
+    if (existsSync(worktreeDir)) {
+        try {
+            for (const d of readdirSync(worktreeDir)) {
+                if (d.startsWith("M") && existsSync(join(worktreeDir, d, ".gsd", "auto.lock"))) {
+                    mids.add(d);
+                }
+            }
+        }
+        catch { /* skip */ }
+    }
+    return [...mids].sort();
+}
+function querySliceProgress(basePath, mid) {
+    const dbPath = join(basePath, ".gsd", "worktrees", mid, ".gsd", "gsd.db");
+    if (!existsSync(dbPath))
+        return [];
+    try {
+        const sql = `SELECT s.id, s.status, COUNT(t.id), SUM(CASE WHEN t.status='complete' THEN 1 ELSE 0 END) FROM slices s LEFT JOIN tasks t ON s.milestone_id=t.milestone_id AND s.id=t.slice_id WHERE s.milestone_id='${mid}' GROUP BY s.id ORDER BY s.id`;
+        const result = spawnSync("sqlite3", [dbPath, sql], { timeout: 3000, encoding: "utf-8" });
+        const out = (result.stdout || "").trim();
+        if (!out || result.status !== 0)
+            return [];
+        return out.split("\n").map((line) => {
+            const [id, status, total, done] = line.split("|");
+            return { id, status, total: parseInt(total, 10), done: parseInt(done || "0", 10) };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function extractCostFromNdjson(basePath, mid) {
+    const stdoutPath = join(basePath, ".gsd", "parallel", `${mid}.stdout.log`);
+    if (!existsSync(stdoutPath))
+        return 0;
+    try {
+        const content = readFileSync(stdoutPath, "utf-8");
+        let total = 0;
+        for (const line of content.split("\n")) {
+            if (!line.includes("message_end"))
+                continue;
+            try {
+                const obj = JSON.parse(line);
+                if (obj.type === "message_end") {
+                    const cost = obj.message?.usage?.cost?.total;
+                    if (typeof cost === "number")
+                        total += cost;
+                }
+            }
+            catch { /* skip */ }
+        }
+        return total;
+    }
+    catch {
+        return 0;
+    }
+}
+function queryRecentCompletions(basePath, mid) {
+    const dbPath = join(basePath, ".gsd", "worktrees", mid, ".gsd", "gsd.db");
+    if (!existsSync(dbPath))
+        return [];
+    try {
+        const sql = `SELECT id, slice_id, one_liner FROM tasks WHERE milestone_id='${mid}' AND status='complete' AND completed_at IS NOT NULL ORDER BY completed_at DESC LIMIT 5`;
+        const result = spawnSync("sqlite3", [dbPath, sql], { timeout: 3000, encoding: "utf-8" });
+        const out = (result.stdout || "").trim();
+        if (!out || result.status !== 0)
+            return [];
+        return out.split("\n").map((line) => {
+            const [taskId, sliceId, oneLiner] = line.split("|");
+            return `✓ ${mid}/${sliceId}/${taskId}${oneLiner ? ": " + oneLiner : ""}`;
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function collectWorkerData(basePath) {
+    const mids = discoverWorkers(basePath);
+    const parallelDir = join(basePath, ".gsd", "parallel");
+    const workers = [];
+    for (const mid of mids) {
+        const status = readJsonSafe(join(parallelDir, `${mid}.status.json`));
+        const lock = readJsonSafe(join(basePath, ".gsd", "worktrees", mid, ".gsd", "auto.lock"));
+        const slices = querySliceProgress(basePath, mid);
+        const pid = lock?.pid || status?.pid || 0;
+        const alive = pid ? isPidAlive(pid) : false;
+        // Heartbeat: prefer status.json if PID matches, else use file mtime
+        let heartbeatAge = Infinity;
+        const statusPidMatches = status?.pid === pid && status?.lastHeartbeat;
+        if (statusPidMatches) {
+            heartbeatAge = Date.now() - status.lastHeartbeat;
+        }
+        else {
+            const mtimes = [];
+            const stdoutLog = join(parallelDir, `${mid}.stdout.log`);
+            const stderrLog = join(parallelDir, `${mid}.stderr.log`);
+            if (existsSync(stdoutLog))
+                mtimes.push(statSync(stdoutLog).mtimeMs);
+            if (existsSync(stderrLog))
+                mtimes.push(statSync(stderrLog).mtimeMs);
+            if (lock?.unitStartedAt)
+                mtimes.push(new Date(lock.unitStartedAt).getTime());
+            if (mtimes.length > 0)
+                heartbeatAge = Date.now() - Math.max(...mtimes);
+        }
+        let cost = status?.cost || 0;
+        if (cost === 0)
+            cost = extractCostFromNdjson(basePath, mid);
+        const totalTasks = slices.reduce((sum, s) => sum + s.total, 0);
+        const doneTasks = slices.reduce((sum, s) => sum + s.done, 0);
+        const doneSlices = slices.filter((s) => s.status === "complete").length;
+        const elapsed = status?.startedAt
+            ? Date.now() - status.startedAt
+            : lock?.startedAt
+                ? Date.now() - new Date(lock.startedAt).getTime()
+                : 0;
+        // Errors from stderr (last 4KB, only new content)
+        const errors = [];
+        const stderrLog = join(parallelDir, `${mid}.stderr.log`);
+        if (existsSync(stderrLog)) {
+            const content = tailRead(stderrLog, 4096);
+            for (const line of content.trim().split("\n").slice(-5)) {
+                if (line.includes("error") || line.includes("Error") || line.includes("exited")) {
+                    errors.push(line.trim());
+                }
+            }
+        }
+        workers.push({
+            mid,
+            pid,
+            alive,
+            state: alive ? "running" : (status?.state || "dead"),
+            cost,
+            heartbeatAge,
+            currentUnit: lock?.unitId || null,
+            unitType: lock?.unitType || null,
+            unitElapsed: lock?.unitStartedAt ? Date.now() - new Date(lock.unitStartedAt).getTime() : 0,
+            elapsed,
+            totalTasks,
+            doneTasks,
+            totalSlices: slices.length,
+            doneSlices,
+            slices,
+            errors,
+        });
+    }
+    return workers;
+}
+// ─── Rendering Helpers ────────────────────────────────────────────────────
+function unitTypeLabel(unitType) {
+    const labels = {
+        "execute-task": "EXEC",
+        "research-slice": "RSRCH",
+        "plan-slice": "PLAN",
+        "complete-slice": "DONE",
+        "complete-task": "DONE",
+        "reassess": "ASSESS",
+        "validate": "VALID",
+        "reassess-roadmap": "ASSESS",
+    };
+    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;
+    theme;
+    onClose;
+    basePath;
+    refreshTimer;
+    workers = [];
+    events = [];
+    cachedLines;
+    scrollOffset = 0;
+    disposed = false;
+    resizeHandler = null;
+    constructor(tui, theme, onClose, basePath) {
+        this.tui = tui;
+        this.theme = theme;
+        this.onClose = onClose;
+        this.basePath = basePath || process.cwd();
+        this.resizeHandler = () => {
+            if (this.disposed)
+                return;
+            this.invalidate();
+            this.tui.requestRender();
+        };
+        process.stdout.on("resize", this.resizeHandler);
+        this.refresh();
+        this.refreshTimer = setInterval(() => this.refresh(), 5000);
+    }
+    refresh() {
+        if (this.disposed)
+            return;
+        this.workers = collectWorkerData(this.basePath);
+        // Collect completion events
+        for (const wk of this.workers) {
+            const completions = queryRecentCompletions(this.basePath, wk.mid);
+            for (const evt of completions) {
+                if (!this.events.includes(evt))
+                    this.events.push(evt);
+            }
+        }
+        this.events = this.events.slice(-10);
+        this.cachedLines = undefined;
+        this.tui.requestRender();
+    }
+    dispose() {
+        this.disposed = true;
+        clearInterval(this.refreshTimer);
+        if (this.resizeHandler) {
+            process.stdout.removeListener("resize", this.resizeHandler);
+            this.resizeHandler = null;
+        }
+    }
+    handleInput(data) {
+        if (matchesKey(data, Key.escape) || data === "q") {
+            this.dispose();
+            this.onClose();
+            return;
+        }
+        if (matchesKey(data, Key.down) || data === "j") {
+            this.scrollOffset++;
+            this.invalidate();
+            this.tui.requestRender();
+            return;
+        }
+        if (matchesKey(data, Key.up) || data === "k") {
+            this.scrollOffset = Math.max(0, this.scrollOffset - 1);
+            this.invalidate();
+            this.tui.requestRender();
+            return;
+        }
+    }
+    invalidate() {
+        this.cachedLines = undefined;
+    }
+    render(width) {
+        if (this.cachedLines)
+            return this.cachedLines;
+        const t = this.theme;
+        const lines = [];
+        const w = Math.max(width, 60);
+        // Header
+        const totalCost = this.workers.reduce((s, wk) => s + wk.cost, 0);
+        const aliveCount = this.workers.filter((wk) => wk.alive).length;
+        const now = new Date().toLocaleTimeString();
+        lines.push(t.bold(t.fg("accent", " GSD Parallel Monitor ")));
+        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)));
+        if (this.workers.length === 0) {
+            lines.push("");
+            lines.push(t.fg("warning", "  No parallel workers found."));
+            lines.push(t.fg("muted", "  Run /gsd parallel start to begin."));
+        }
+        else {
+            for (const wk of this.workers) {
+                lines.push("");
+                // Health + ID + state
+                const healthColor = wk.alive ? "success" : "error";
+                const glyph = healthGlyph(wk.alive, wk.heartbeatAge);
+                const stateText = wk.alive
+                    ? t.fg("success", "RUNNING")
+                    : t.fg("error", t.bold("DEAD"));
+                const heartbeatText = wk.heartbeatAge === Infinity
+                    ? "never"
+                    : formatDuration(wk.heartbeatAge) + " ago";
+                lines.push(`  ${t.fg(healthColor, glyph)}  ${t.bold(wk.mid)}  ${stateText}  ` +
+                    t.fg("muted", `PID ${wk.pid}  │  elapsed ${formatDuration(wk.elapsed)}  │  `) +
+                    `cost ${t.bold("$" + wk.cost.toFixed(2))}  ` +
+                    t.fg("muted", "│  heartbeat ") + t.fg(healthColor, heartbeatText));
+                // Current unit
+                if (wk.currentUnit) {
+                    const phaseColor = wk.unitType === "execute-task" ? "accent"
+                        : wk.unitType === "research-slice" ? "warning"
+                            : wk.unitType?.includes("complete") ? "success"
+                                : "text";
+                    lines.push(`     ${t.fg("muted", "▸")} ${t.fg(phaseColor, unitTypeLabel(wk.unitType))}  ${wk.currentUnit}  ` +
+                        t.fg("muted", `(${formatDuration(wk.unitElapsed)})`));
+                }
+                else if (!wk.alive) {
+                    lines.push(`     ${t.fg("muted", "▸")} ${t.fg("error", "stopped")}`);
+                }
+                else {
+                    lines.push(`     ${t.fg("muted", "▸ idle / between units")}`);
+                }
+                // Slice progress chips
+                if (wk.slices.length > 0) {
+                    const chips = wk.slices.map((s) => {
+                        const pct = s.total > 0 ? s.done / s.total : 0;
+                        const color = s.status === "complete" ? "success" : pct > 0 ? "warning" : "muted";
+                        return t.fg(color, `${s.id}:${s.done}/${s.total}`);
+                    });
+                    lines.push(`     ${t.fg("muted", "slices")}  ${chips.join("  ")}`);
+                    // Task progress bar
+                    const bar = progressBar(wk.doneTasks, wk.totalTasks, 25);
+                    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", `(${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)}`);
+                }
+            }
+        }
+        // Event feed
+        lines.push("");
+        lines.push(t.fg("muted", "─".repeat(w)));
+        lines.push(`  ${t.bold("Recent Events")}`);
+        if (this.events.length === 0) {
+            lines.push(t.fg("muted", "  No events yet..."));
+        }
+        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+\//, "")}`);
+            }
+        }
+        // Footer
+        lines.push("");
+        const allDone = this.workers.length > 0 && this.workers.every((wk) => !wk.alive);
+        if (allDone) {
+            lines.push(t.bold(t.fg("success", "  ALL WORKERS COMPLETE")));
+            for (const wk of this.workers) {
+                lines.push(`  ${wk.mid}  $${wk.cost.toFixed(2)}  │  ${wk.doneSlices}/${wk.totalSlices} slices  ` +
+                    `${wk.doneTasks}/${wk.totalTasks} tasks  │  ${formatDuration(wk.elapsed)}`);
+            }
+            lines.push(`  ${t.bold("Total: $" + this.workers.reduce((s, wk) => s + wk.cost, 0).toFixed(2))}`);
+        }
+        lines.push(t.fg("muted", "  ESC/q to close  │  ↑↓ scroll"));
+        // Apply scroll — use terminal rows as height estimate
+        const termHeight = process.stdout.rows || 40;
+        const visible = lines.slice(this.scrollOffset, this.scrollOffset + termHeight);
+        this.cachedLines = visible;
+        return visible;
+    }
+}