@bretwardjames/ghp-cli 0.16.3 → 0.18.0

package/dist/commands/dashboard-pipeline.js

@@ -6,15 +6,17 @@
  *   - window mode: agents are in separate windows. [1-9] pulls pane into dashboard window.
  */
 import chalk from 'chalk';
-import { execFile } from 'child_process';
+import { execFile, spawn } from 'child_process';
 import { promisify } from 'util';
 import { getAgentSummaries } from '@bretwardjames/ghp-core';
 import { getMainWorktreeRoot } from '../git-utils.js';
-import { getConfig } from '../config.js';
-import { getAllPipelineEntries, getIntegrationTriggerStage, getStageEmoji } from '../pipeline-registry.js';
+import { getConfig, getParallelWorkConfig } from '../config.js';
+import { resolveHookScript, runUserHookScript } from './pipeline-commands.js';
+import { getAllPipelineEntries, getIntegrationTriggerStage, getPipelineStages, getStageEmoji } from '../pipeline-registry.js';
 import { readSwapState } from './worktree-swap-state.js';
 import { worktreeCleanCommand, worktreeNextCommand } from './worktree-swap.js';
 import { registerCleanupHandler, resetExitState } from '../exit.js';
+import { adminWindowName, agentSessionName, getTmuxPrefix, tmuxSessionExists } from '../terminal-utils.js';
 // Guard: when true, the dashboard cleanup handler is a no-op
 let suppressCleanup = false;
 /**
@@ -124,6 +126,57 @@ async function selectPane(paneId) {
     }
     catch { /* ignore */ }
 }
+// ---------------------------------------------------------------------------
+// tmux helpers — session mode (viewport with nested attach)
+// ---------------------------------------------------------------------------
+/** Create the viewport pane next to the dashboard. Returns the pane ID. */
+async function createViewportPane(dashPaneId) {
+    const { dashboard: dbConfig } = getParallelWorkConfig();
+    const dirFlag = dbConfig.focusedAgent.direction === 'horizontal' ? '-h' : '-v';
+    const size = dbConfig.focusedAgent.size;
+    try {
+        const { stdout } = await execFileAsync('tmux', [
+            'split-window', dirFlag, '-l', size, '-t', dashPaneId, '-d',
+            '-P', '-F', '#{pane_id}',
+            'echo "Press [1-9] to view an agent"; read',
+        ]);
+        return stdout.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Attach the viewport pane to an agent session via respawn-pane. */
+async function attachViewportToSession(viewportPaneId, sessionName) {
+    try {
+        // TMUX="" prevents nested-tmux errors; the respawn replaces the viewport process.
+        // The = prefix forces exact session name matching (prevents ghp-agent-8 matching ghp-agent-86).
+        // Session names are validated to [a-zA-Z0-9_-]+ via prefix validation + integer issue numbers.
+        const escaped = sessionName.replace(/'/g, "'\\''");
+        await execFileAsync('tmux', [
+            'respawn-pane', '-k', '-t', viewportPaneId,
+            `TMUX="" tmux attach-session -t '=${escaped}'`,
+        ]);
+    }
+    catch { /* best effort */ }
+}
+/** Detach the viewport pane (show placeholder). */
+async function detachViewport(viewportPaneId) {
+    try {
+        await execFileAsync('tmux', [
+            'respawn-pane', '-k', '-t', viewportPaneId,
+            'echo "Press [1-9] to view an agent"; read',
+        ]);
+    }
+    catch { /* best effort */ }
+}
+/** Kill the viewport pane. */
+async function killViewportPane(viewportPaneId) {
+    try {
+        await execFileAsync('tmux', ['kill-pane', '-t', viewportPaneId]);
+    }
+    catch { /* best effort */ }
+}
 /** Get the pane ID of the dashboard itself (this process). */
 function getDashboardPaneId() {
     // TMUX_PANE is set by tmux for each pane's process — unlike display-message
@@ -131,10 +184,33 @@ function getDashboardPaneId() {
     return process.env.TMUX_PANE || null;
 }
 // ---------------------------------------------------------------------------
+// Hook: dashboard-opened
+// ---------------------------------------------------------------------------
+async function fireDashboardOpenedHook(paneId, mode) {
+    const repoRoot = await getMainWorktreeRoot();
+    if (!repoRoot)
+        return;
+    const scriptPath = resolveHookScript(repoRoot, 'dashboard-opened', mode);
+    if (!scriptPath)
+        return;
+    try {
+        const child = spawn(scriptPath, [], {
+            cwd: repoRoot,
+            stdio: ['pipe', 'ignore', 'ignore'],
+            detached: true,
+        });
+        child.stdin.write(JSON.stringify({ pane_id: paneId, window_name: adminWindowName() }));
+        child.stdin.end();
+        child.unref();
+    }
+    catch { /* silent */ }
+}
+// ---------------------------------------------------------------------------
 // Coordinator pane detection
 // ---------------------------------------------------------------------------
 async function findCoordinatorPane() {
-    const candidates = ['ghp-root', 'ghp-coordinator', 'ghp-main'];
+    const prefix = getTmuxPrefix();
+    const candidates = [`${prefix}-root`, `${prefix}-coordinator`, `${prefix}-main`];
     for (const name of candidates) {
         try {
             const { stdout } = await execFileAsync('tmux', ['display-message', '-t', name, '-p', '#{window_name}']);
@@ -194,18 +270,24 @@ function renderEntry(e, prefix, attached, showAction) {
         console.log(`          ${chalk.dim(`└─ ${e.agent.currentAction.substring(0, 55)}`)}`);
     }
 }
-function renderDashboard(entries, tmuxMode, attached, now, mainDirty) {
+function renderDashboard(entries, tmuxMode, attached, now, mainDirty, hookMode, hookModes) {
     process.stdout.write('\x1b[2J\x1b[H'); // clear
     const triggerStage = getIntegrationTriggerStage();
+    const stages = getPipelineStages();
+    const hasTriggerStage = stages.includes(triggerStage);
     const waiting = entries.filter(e => e.agent?.waitingForInput || e.pipeline.stage === 'needs_attention');
-    const ready = entries.filter(e => e.pipeline.stage === triggerStage && !e.inMainRepo);
+    const ready = hasTriggerStage ? entries.filter(e => e.pipeline.stage === triggerStage && !e.inMainRepo) : [];
     const testing = entries.filter(e => e.inMainRepo);
+    const stopped = entries.filter(e => e.pipeline.stage === 'stopped' &&
+        !e.agent?.waitingForInput &&
+        !e.inMainRepo);
     const working = entries.filter(e => !e.agent?.waitingForInput &&
         e.pipeline.stage !== 'needs_attention' &&
-        e.pipeline.stage !== triggerStage &&
+        e.pipeline.stage !== 'stopped' &&
+        (!hasTriggerStage || e.pipeline.stage !== triggerStage) &&
         !e.inMainRepo);
-    // Number all entries for keypress selection (attention first, then working)
-    const numbered = [...waiting, ...working];
+    // Number all entries for keypress selection (attention first, then stopped, then working)
+    const numbered = [...waiting, ...stopped, ...working];
     numbered.forEach((e, i) => { e.attentionIndex = i + 1; });
     const attachedLabel = attached
         ? chalk.bgCyan.black(` VIEWING: #${attached.issueNumber} `)
@@ -220,6 +302,14 @@ function renderDashboard(entries, tmuxMode, attached, now, mainDirty) {
         }
         console.log();
     }
+    if (stopped.length > 0) {
+        console.log(chalk.dim.bold('  STOPPED'));
+        for (const e of stopped) {
+            const key = e.attentionIndex ? chalk.dim(`[${e.attentionIndex}]`) : '   ';
+            renderEntry(e, `${key} ${chalk.dim('⏸')}`, attached, false);
+        }
+        console.log();
+    }
     if (ready.length > 0) {
         const blocked = mainDirty ? chalk.red.bold('  BLOCKED') + chalk.red(' — main repo has uncommitted changes') : '';
         console.log(chalk.green.bold('  READY FOR INTEGRATION') + blocked);
@@ -261,15 +351,26 @@ function renderDashboard(entries, tmuxMode, attached, now, mainDirty) {
         console.log();
     }
     console.log(chalk.dim('─'.repeat(70)));
+    const modeLabel = (hookModes && hookModes.length > 0)
+        ? `  [m] mode: ${hookMode ? chalk.cyan(hookMode) : chalk.dim('default')}`
+        : '';
     if (tmuxMode === 'pane') {
-        console.log(chalk.dim('[1-9] focus agent  [i] next integration  [x] clean  [q] quit'));
+        console.log(chalk.dim(`[1-9] focus agent${modeLabel}  [i] next integration  [x] clean  [q] quit`));
+    }
+    else if (tmuxMode === 'session') {
+        if (attached) {
+            console.log(chalk.dim(`[1-9] swap  [esc] detach${modeLabel}  [i] next integration  [x] clean  [q] quit`));
+        }
+        else {
+            console.log(chalk.dim(`[1-9] attach session${modeLabel}  [i] next integration  [x] clean  [q] quit`));
+        }
     }
     else {
         if (attached) {
-            console.log(chalk.dim('[1-9] swap  [esc] send back  [c] coordinator  [q] quit'));
+            console.log(chalk.dim(`[1-9] swap  [esc] send back${modeLabel}  [c] coordinator  [q] quit`));
         }
         else {
-            console.log(chalk.dim('[1-9] pull pane  [i] next integration  [x] clean  [c] coordinator  [q] quit'));
+            console.log(chalk.dim(`[1-9] pull pane${modeLabel}  [i] next integration  [x] clean  [c] coordinator  [q] quit`));
         }
     }
 }
@@ -292,6 +393,18 @@ export async function pipelineDashboardCommand(options = {}) {
     let dashboardPaneId = null;
     let coordinatorWindow = null;
     let refreshTimer = null;
+    // Session mode viewport state
+    let viewport = null;
+    // Hook mode state — runtime only, initialized from config
+    const pipelineConfig = getConfig('pipeline');
+    const hookModes = pipelineConfig?.hookModes ?? [];
+    let currentHookMode = pipelineConfig?.defaultHookMode ?? null;
+    // Validate that defaultHookMode is in the hookModes list
+    if (currentHookMode && hookModes.length > 0 && !hookModes.includes(currentHookMode)) {
+        currentHookMode = hookModes[0];
+    }
+    if (hookModes.length === 0)
+        currentHookMode = null;
     if (process.env.TMUX) {
         dashboardPaneId = getDashboardPaneId();
         if (tmuxMode === 'window') {
@@ -315,19 +428,43 @@ export async function pipelineDashboardCommand(options = {}) {
         }));
     }
     async function refresh() {
+        // Session mode: validate attached session still exists
+        if (tmuxMode === 'session' && viewport?.attachedIssue != null) {
+            const sessionName = agentSessionName(viewport.attachedIssue);
+            const exists = await tmuxSessionExists(sessionName);
+            if (!exists) {
+                // Fire agent-unfocused hook before clearing state (fire-and-forget)
+                const repoRoot = await getMainWorktreeRoot();
+                if (repoRoot) {
+                    const entry = getAllPipelineEntries(repoRoot).find(e => e.issueNumber === viewport.attachedIssue);
+                    if (entry) {
+                        runUserHookScript('agent-unfocused', agentPayload(entry), entry.worktreePath, currentHookMode);
+                    }
+                }
+                viewport.attachedIssue = null;
+                attached = null;
+                await detachViewport(viewport.paneId);
+            }
+        }
         const repoRoot = await getMainWorktreeRoot();
         const entries = await buildEntries();
         const dirty = repoRoot ? await isMainRepoDirty(repoRoot) : false;
-        renderDashboard(entries, tmuxMode, attached, new Date().toLocaleTimeString(), dirty);
+        renderDashboard(entries, tmuxMode, attached, new Date().toLocaleTimeString(), dirty, currentHookMode, hookModes);
     }
     function getNumberedEntry(entries, digit) {
         const triggerStage = getIntegrationTriggerStage();
+        const stages = getPipelineStages();
+        const hasTriggerStage = stages.includes(triggerStage);
         const waiting = entries.filter(e => e.agent?.waitingForInput || e.pipeline.stage === 'needs_attention');
+        const stopped = entries.filter(e => e.pipeline.stage === 'stopped' &&
+            !e.agent?.waitingForInput &&
+            !e.inMainRepo);
         const working = entries.filter(e => !e.agent?.waitingForInput &&
             e.pipeline.stage !== 'needs_attention' &&
-            e.pipeline.stage !== triggerStage &&
+            e.pipeline.stage !== 'stopped' &&
+            (!hasTriggerStage || e.pipeline.stage !== triggerStage) &&
             !e.inMainRepo);
-        const numbered = [...waiting, ...working];
+        const numbered = [...waiting, ...stopped, ...working];
         return numbered[digit - 1];
     }
     // ---------------------------------------------------------------------------
@@ -348,12 +485,68 @@ export async function pipelineDashboardCommand(options = {}) {
     // ---------------------------------------------------------------------------
     // Window mode: pull/release
     // ---------------------------------------------------------------------------
+    /** Build the JSON payload for a focused/unfocused hook. */
+    function agentPayload(entry) {
+        return JSON.stringify({
+            issueNumber: entry.issueNumber,
+            worktreePath: entry.worktreePath,
+            branch: entry.branch,
+        });
+    }
+    /** Fire the agent-swapped hook, or fall back to sequential unfocus→focus. */
+    async function fireSwapHook(oldEntry, newEntry) {
+        const repoRoot = await getMainWorktreeRoot();
+        if (!repoRoot)
+            return;
+        const swapScript = resolveHookScript(repoRoot, 'agent-swapped', currentHookMode);
+        if (swapScript) {
+            // Atomic swap hook
+            const payload = JSON.stringify({
+                old: { issueNumber: oldEntry.issueNumber, worktreePath: oldEntry.worktreePath, branch: oldEntry.branch },
+                new: { issueNumber: newEntry.issueNumber, worktreePath: newEntry.worktreePath, branch: newEntry.branch },
+            });
+            try {
+                const child = spawn(swapScript, [], {
+                    cwd: newEntry.worktreePath,
+                    stdio: ['pipe', 'ignore', 'ignore'],
+                    detached: true,
+                });
+                child.stdin.write(payload);
+                child.stdin.end();
+                child.unref();
+            }
+            catch { /* silent */ }
+        }
+        else {
+            // Fallback: sequential unfocus→focus (respecting hookModeSwapOrder)
+            // Await the first to guarantee ordering; second is fire-and-forget
+            const swapOrder = pipelineConfig?.hookModeSwapOrder ?? 'unfocus-first';
+            if (swapOrder === 'focus-first') {
+                await runUserHookScript('agent-focused', agentPayload(newEntry), newEntry.worktreePath, currentHookMode);
+                runUserHookScript('agent-unfocused', agentPayload(oldEntry), oldEntry.worktreePath, currentHookMode);
+            }
+            else {
+                await runUserHookScript('agent-unfocused', agentPayload(oldEntry), oldEntry.worktreePath, currentHookMode);
+                runUserHookScript('agent-focused', agentPayload(newEntry), newEntry.worktreePath, currentHookMode);
+            }
+        }
+    }
     async function pullAgentPane(issueNumber) {
-        // Hot-swap: release current pane before pulling the new one
+        let previousEntry = null;
+        // Hot-swap: if already viewing a different agent
         if (attached) {
             if (attached.issueNumber === issueNumber)
                 return; // already showing this one
-            await sendPaneBack();
+            // Look up the old entry before releasing
+            if (attached.issueNumber > 0) {
+                const repoRoot = await getMainWorktreeRoot();
+                if (repoRoot) {
+                    previousEntry = getAllPipelineEntries(repoRoot).find(e => e.issueNumber === attached.issueNumber) ?? null;
+                }
+            }
+            // Release the tmux pane
+            await releasePaneToWindow(attached);
+            attached = null;
         }
         if (!dashboardPaneId)
             return;
@@ -367,9 +560,13 @@ export async function pipelineDashboardCommand(options = {}) {
         const agent = await findAgentByWorktreePath(pipelineEntry.worktreePath);
         if (!agent)
             return;
+        // Read focused agent config for direction/size
+        const { dashboard: dbConfig } = getParallelWorkConfig();
+        const dirFlag = dbConfig.focusedAgent.direction === 'horizontal' ? '-h' : '-v';
+        const size = dbConfig.focusedAgent.size;
         // Pull the pane into dashboard
         try {
-            await execFileAsync('tmux', ['join-pane', '-v', '-l', '50%', '-t', dashboardPaneId, '-s', agent.paneId]);
+            await execFileAsync('tmux', ['join-pane', dirFlag, '-l', size, '-t', dashboardPaneId, '-s', agent.paneId]);
         }
         catch {
             return;
@@ -380,24 +577,120 @@ export async function pipelineDashboardCommand(options = {}) {
         }
         catch { /* best effort */ }
         attached = { issueNumber, paneId: agent.paneId, sourceWindowName: agent.windowName };
+        // Fire hooks
+        if (previousEntry) {
+            // Hot-swap: atomic agent-swapped or sequential fallback
+            fireSwapHook(previousEntry, pipelineEntry);
+        }
+        else {
+            // Fresh pull: agent-focused only
+            runUserHookScript('agent-focused', agentPayload(pipelineEntry), pipelineEntry.worktreePath, currentHookMode);
+        }
         await refresh();
     }
     async function sendPaneBack() {
         if (!attached)
             return;
+        // Fire agent-unfocused hook before releasing (fire-and-forget)
+        if (attached.issueNumber > 0) {
+            const repoRoot = await getMainWorktreeRoot();
+            if (repoRoot) {
+                const entry = getAllPipelineEntries(repoRoot).find(e => e.issueNumber === attached.issueNumber);
+                if (entry) {
+                    runUserHookScript('agent-unfocused', agentPayload(entry), entry.worktreePath, currentHookMode);
+                }
+            }
+        }
         await releasePaneToWindow(attached);
         attached = null;
         await refresh();
     }
     // ---------------------------------------------------------------------------
+    // Session mode: attach/detach via viewport
+    // ---------------------------------------------------------------------------
+    async function attachSessionToViewport(issueNumber) {
+        if (!viewport)
+            return;
+        if (viewport.attachedIssue === issueNumber)
+            return; // already attached
+        const sessionName = agentSessionName(issueNumber);
+        const exists = await tmuxSessionExists(sessionName);
+        if (!exists)
+            return;
+        let previousEntry = null;
+        // Hot-swap: if already viewing a different agent
+        if (viewport.attachedIssue != null) {
+            const repoRoot = await getMainWorktreeRoot();
+            if (repoRoot) {
+                previousEntry = getAllPipelineEntries(repoRoot).find(e => e.issueNumber === viewport.attachedIssue) ?? null;
+            }
+        }
+        await attachViewportToSession(viewport.paneId, sessionName);
+        viewport.attachedIssue = issueNumber;
+        attached = { issueNumber, paneId: viewport.paneId, sourceWindowName: '' };
+        // Set pane border title
+        try {
+            await execFileAsync('tmux', ['select-pane', '-t', viewport.paneId, '-T', `Agent #${issueNumber}`]);
+        }
+        catch { /* best effort */ }
+        // Fire hooks
+        const repoRoot = await getMainWorktreeRoot();
+        if (repoRoot) {
+            const newEntry = getAllPipelineEntries(repoRoot).find(e => e.issueNumber === issueNumber);
+            if (newEntry) {
+                if (previousEntry) {
+                    fireSwapHook(previousEntry, newEntry);
+                }
+                else {
+                    runUserHookScript('agent-focused', agentPayload(newEntry), newEntry.worktreePath, currentHookMode);
+                }
+            }
+        }
+        await refresh();
+    }
+    /** Fire agent-unfocused hook and kill the viewport pane. Fire-and-forget safe. */
+    function cleanupViewport() {
+        if (!viewport)
+            return;
+        if (viewport.attachedIssue != null) {
+            getMainWorktreeRoot().then(repoRoot => {
+                if (!repoRoot)
+                    return;
+                const entry = getAllPipelineEntries(repoRoot).find(e => e.issueNumber === viewport.attachedIssue);
+                if (entry)
+                    runUserHookScript('agent-unfocused', agentPayload(entry), entry.worktreePath, currentHookMode);
+            }).catch(() => { });
+        }
+        killViewportPane(viewport.paneId).catch(() => { });
+    }
+    async function detachSessionFromViewport() {
+        if (!viewport || viewport.attachedIssue == null)
+            return;
+        // Fire agent-unfocused hook
+        const repoRoot = await getMainWorktreeRoot();
+        if (repoRoot) {
+            const entry = getAllPipelineEntries(repoRoot).find(e => e.issueNumber === viewport.attachedIssue);
+            if (entry) {
+                runUserHookScript('agent-unfocused', agentPayload(entry), entry.worktreePath, currentHookMode);
+            }
+        }
+        await detachViewport(viewport.paneId);
+        viewport.attachedIssue = null;
+        attached = null;
+        await refresh();
+    }
+    // ---------------------------------------------------------------------------
     // Keypress handler
     // ---------------------------------------------------------------------------
     async function handleKey(key) {
-        // esc — send pane back (window mode) or refocus dashboard (pane mode)
+        // esc — send pane back (window mode), detach (session mode), or refocus dashboard (pane mode)
         if (key === '\x1b') {
             if (tmuxMode === 'pane' && dashboardPaneId) {
                 await selectPane(dashboardPaneId);
             }
+            else if (tmuxMode === 'session') {
+                await detachSessionFromViewport();
+            }
             else if (tmuxMode === 'window' && attached) {
                 await sendPaneBack();
             }
@@ -405,8 +698,12 @@ export async function pipelineDashboardCommand(options = {}) {
         }
         // q — quit
         if (key === 'q' || key === 'Q') {
-            if (attached)
+            if (tmuxMode === 'session' && viewport) {
+                cleanupViewport();
+            }
+            else if (attached) {
                 await sendPaneBack();
+            }
             if (refreshTimer)
                 clearInterval(refreshTimer);
             if (process.stdin.isTTY) {
@@ -445,13 +742,31 @@ export async function pipelineDashboardCommand(options = {}) {
             await refresh();
             return;
         }
+        // m — cycle hook modes (includes null/"default" as the last position)
+        if (key === 'm' || key === 'M') {
+            if (hookModes.length > 0) {
+                const oldMode = currentHookMode;
+                const currentIdx = currentHookMode ? hookModes.indexOf(currentHookMode) : -1;
+                const nextIdx = currentIdx + 1;
+                // After the last named mode, wrap to null (default/unsuffixed hooks)
+                currentHookMode = nextIdx < hookModes.length ? hookModes[nextIdx] : null;
+                // Fire mode-switched hook (fire-and-forget, never mode-suffixed)
+                const modePayload = JSON.stringify({ oldMode: oldMode ?? null, newMode: currentHookMode ?? null });
+                const modeRoot = await getMainWorktreeRoot();
+                if (modeRoot) {
+                    runUserHookScript('mode-switched', modePayload, modeRoot, null);
+                }
+                await refresh();
+            }
+            return;
+        }
         // x — clean
         if (key === 'x' || key === 'X') {
             await safeExec(() => worktreeCleanCommand({}));
             await refresh();
             return;
         }
-        // 1-9 — zoom (pane mode) or pull (window mode)
+        // 1-9 — focus (pane mode), pull (window mode), or attach (session mode)
         const digit = parseInt(key, 10);
         if (!isNaN(digit) && digit >= 1 && digit <= 9) {
             const entries = await buildEntries();
@@ -461,6 +776,9 @@ export async function pipelineDashboardCommand(options = {}) {
             if (tmuxMode === 'pane') {
                 await focusAgent(entry.pipeline.issueNumber);
             }
+            else if (tmuxMode === 'session') {
+                await attachSessionToViewport(entry.pipeline.issueNumber);
+            }
             else {
                 await pullAgentPane(entry.pipeline.issueNumber);
             }
@@ -470,7 +788,18 @@ export async function pipelineDashboardCommand(options = {}) {
     // ---------------------------------------------------------------------------
     // Start
     // ---------------------------------------------------------------------------
+    // Session mode: create viewport pane at startup
+    if (tmuxMode === 'session' && dashboardPaneId) {
+        const vpPaneId = await createViewportPane(dashboardPaneId);
+        if (vpPaneId) {
+            viewport = { paneId: vpPaneId, attachedIssue: null };
+        }
+    }
     await refresh();
+    // Fire dashboard-opened hook (fire-and-forget)
+    if (dashboardPaneId) {
+        fireDashboardOpenedHook(dashboardPaneId, currentHookMode);
+    }
     refreshTimer = setInterval(() => {
         refresh().catch(() => { });
     }, intervalMs);
@@ -479,8 +808,12 @@ export async function pipelineDashboardCommand(options = {}) {
             return;
         if (refreshTimer)
             clearInterval(refreshTimer);
-        if (attached)
+        if (viewport) {
+            cleanupViewport();
+        }
+        else if (attached) {
             releasePaneToWindow(attached).catch(() => { });
+        }
         process.stdin.setRawMode?.(false);
         process.stdin.pause();
     });
@@ -490,8 +823,12 @@ export async function pipelineDashboardCommand(options = {}) {
         process.stdin.setEncoding('utf-8');
         process.stdin.on('data', (key) => {
             if (key === '\u0003') {
-                if (attached)
+                if (viewport) {
+                    cleanupViewport();
+                }
+                else if (attached) {
                     releasePaneToWindow(attached).catch(() => { });
+                }
                 if (refreshTimer)
                     clearInterval(refreshTimer);
                 process.stdin.setRawMode(false);