commandmate 0.29.1 → 0.30.0

package/dist/server/src/lib/cli-tools/gemini.js

@@ -73,8 +73,17 @@ class GeminiTool extends base_1.BaseCLITool {
         const exists = await (0, tmux_1.hasSession)(sessionName);
         if (exists) {
             await this.reconcileExistingSession(sessionName);
-            logger.info('gemini-session-sessionname');
-            return;
+            // Issue #2070: this branch used to return unconditionally. A tmux session
+            // outlives the agent that was launched into it — a quit, a self-update, a
+            // crash — and the launch was then skipped for a pane holding nothing but a
+            // shell prompt, which left `kill-session` by hand as the only recovery.
+            // When the tool is gone we fall THROUGH and re-send the launch command
+            // into the same pane.
+            if (await this.isToolLive(sessionName, { confirm: true })) {
+                logger.info('gemini-session-sessionname');
+                return;
+            }
+            logger.warn('gemini-session-relaunch', { sessionName });
         }
         // Issue #1762: fence this instance's structured events off from the process
         // that used to hold the same (worktree, tool, instance) key. On the creation
@@ -82,16 +91,25 @@ class GeminiTool extends base_1.BaseCLITool {
         // pane exists, so no live pane is ever judged against a stale generation.
         // Bumped even if the launch below then fails: falling back to the screen
         // scraper is always safe, trusting a dead session's events is not.
+        //
+        // Issue #2070: reached on the RELAUNCH path too — the pane is the same one,
+        // but the process is not, and the dead process's events must not be read as
+        // the new one's.
         (0, agent_session_lifecycle_1.beginAgentSession)({ worktreeId, cliToolId: sources_1.GEMINI_CLI_TOOL_ID, instanceId });
         try {
-            // Create tmux session. Scrollback depth comes from the shared
-            // TMUX_HISTORY_LIMIT default (Issue #1624) — do not re-hardcode it here.
-            await (0, tmux_1.createSession)({
-                sessionName,
-                workingDirectory: worktreePath,
-            });
-            // Wait a moment for the session to be created
-            await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.TUI_SESSION_CREATE_WAIT_MS));
+            // Issue #2070: creation only. On the relaunch path the pane already
+            // exists and holds the transcript of the process that died in it; the
+            // launch command is re-sent into that same pane.
+            if (!exists) {
+                // Create tmux session. Scrollback depth comes from the shared
+                // TMUX_HISTORY_LIMIT default (Issue #1624) — do not re-hardcode it here.
+                await (0, tmux_1.createSession)({
+                    sessionName,
+                    workingDirectory: worktreePath,
+                });
+                // Wait a moment for the session to be created
+                await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.TUI_SESSION_CREATE_WAIT_MS));
+            }
             // Start Gemini CLI in interactive mode (no flags = interactive REPL).
             //
             // Issue #1762 hands this worktree its own hooks config, merged into any
@@ -191,6 +209,12 @@ class GeminiTool extends base_1.BaseCLITool {
         if (!exists) {
             throw new Error(`Gemini session ${sessionName} does not exist. Start the session first.`);
         }
+        // Issue #2070: the pane exists, but does the AGENT? An agent that quit,
+        // updated itself or crashed leaves its tmux session behind, and the send
+        // that followed used to sit in the readiness wait until it timed out —
+        // leaving `kill-session` by hand as the only recovery. Relaunches into the
+        // same pane when the tool is gone; costs one `capture-pane` when it is not.
+        await this.relaunchIfToolExited(worktreeId, instanceId);
         try {
             // Verify Gemini is at prompt state before sending
             await this.waitForPrompt(sessionName);

package/dist/server/src/lib/cli-tools/liveness-spec.js

@@ -0,0 +1,214 @@
+"use strict";
+/**
+ * What each tool's pane looks like when the TOOL is still there — one
+ * declaration per tool (Issue #2070).
+ *
+ * The rule these fill in lives in `lib/detection/tool-liveness`; see
+ * {@link ToolLivenessSpec} for why it is a declaration rather than seven
+ * predicates. This module is the table, and it is here for the same reason
+ * `./composer-spec` and `./capture-spec` are: `BaseCLITool.livenessSpec()`
+ * answers from it (the §4 D4 shape, every tool may override), and the two
+ * callers that must NOT instantiate a tool to ask one question — the sidebar's
+ * status poll and `isSessionHealthy` — resolve through {@link resolveLivenessSpec}
+ * instead.
+ *
+ * ## What is measured and what is not
+ *
+ * The frames behind claude / codex / copilot / opencode / gemini were captured
+ * live on 2026-08-31 at the production 200x1000 geometry on a private tmux
+ * socket, launching each tool and then quitting it, and are pinned as fixtures
+ * in `tests/fixtures/tool-liveness-2070.ts`. antigravity was not installed on
+ * that machine and vibe-local needs a local Ollama; both get their prompt and
+ * thinking patterns from `detection/cli-patterns` like everyone else, and the
+ * conservative direction of the shared rule (see step 7 of `judgeToolLiveness`)
+ * is what makes an unmeasured tool safe: the worst an unrecognised frame can do
+ * is answer "alive", which is the pre-#2070 behaviour.
+ *
+ * @module lib/cli-tools/liveness-spec
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LIVENESS_ALIVE_TAIL_LINES = exports.LIVENESS_PROBE_CAPTURE_LINES = void 0;
+exports.resolveLivenessSpec = resolveLivenessSpec;
+const cli_patterns_1 = require("../detection/cli-patterns");
+const tool_liveness_1 = require("../detection/tool-liveness");
+/**
+ * Rows of pane tail a liveness probe asks tmux for.
+ *
+ * claude's number, kept for every tool. The probe reads the BOTTOM of the pane,
+ * so a deeper capture buys nothing and costs the one thing that matters here:
+ * more of the tool's own dead chrome inside {@link ToolLivenessSpec.aliveTailLines}'
+ * reach. Fifty rows covers the composer, its borders and the footer of every
+ * TUI measured (opencode's is the deepest at nine rows).
+ */
+exports.LIVENESS_PROBE_CAPTURE_LINES = 50;
+/**
+ * Content rows from the bottom that {@link ToolLivenessSpec.alivePatterns} may
+ * look at, for every tool but claude.
+ *
+ * Twelve — the same reasoning `COMPOSER_VERIFY_WINDOW_LINES` applies to a
+ * different question: the composer and its chrome are the last thing on the
+ * pane, and a window that reaches past them starts reading scrollback. Measured
+ * floor: opencode's idle chrome is nine content rows (four box rows, the model
+ * row, the bottom border, and up to three wrapped footer rows). Measured
+ * ceiling: the exited codex pane of 0.149.1 puts its banner box eight rows
+ * above the shell prompt and the dead trust dialog a thousand rows above that.
+ */
+exports.LIVENESS_ALIVE_TAIL_LINES = 12;
+/**
+ * The half of a spec that is the same for every tool.
+ *
+ * Only the patterns differ between tools; the shell does not change shape
+ * because a different agent used to be running in it.
+ */
+const SHARED = {
+    probeCaptureLines: exports.LIVENESS_PROBE_CAPTURE_LINES,
+    shellPromptEndings: tool_liveness_1.SHELL_PROMPT_ENDINGS,
+    maxShellPromptLength: tool_liveness_1.MAX_SHELL_PROMPT_LENGTH,
+    fatalPatterns: [],
+    fatalRegexPatterns: [],
+};
+/**
+ * The defaults every tool ADDED by Issue #2070 takes.
+ *
+ * Windowed alive check, the positive `user@host …` prompt forms, and — the one
+ * that matters most — an unreadable frame is NOT an exit. A relaunch hangs off
+ * this verdict, and "the capture threw" is not evidence that anything died.
+ */
+const ADDED_TOOL_DEFAULTS = {
+    aliveTailLines: exports.LIVENESS_ALIVE_TAIL_LINES,
+    shellPromptPatterns: tool_liveness_1.SHELL_PROMPT_LINE_PATTERNS,
+    unreadableIsExited: false,
+};
+/**
+ * Per-tool liveness declarations.
+ *
+ * Each tool's `alivePatterns` is its prompt-ready rule plus whatever else it
+ * draws at the bottom of a pane it still owns — a dialog it is parked on, a
+ * working indicator, a footer. Widening it can only ever make the verdict
+ * "alive", so the list is allowed to be generous; what it must never contain is
+ * a pattern the SHELL can match.
+ */
+const LIVENESS_SPECS = {
+    /**
+     * claude's is `isSessionHealthy`, unchanged, expressed as a declaration.
+     *
+     * Three fields carry that history and are claude's alone: `aliveTailLines:
+     * null` (the check has always tested the whole frame), `shellPromptPatterns:
+     * []` (the length gate and the endings are the whole rule), and
+     * `unreadableIsExited: true` (an empty pane and a capture that threw have
+     * both meant "unhealthy" since it was written). Issue #2070's acceptance
+     * condition is that claude's verdicts do not move, so none of the three may be
+     * "improved" here — a change would have to be its own Issue, with its own
+     * measurements.
+     */
+    claude: {
+        ...SHARED,
+        alivePatterns: [cli_patterns_1.CLAUDE_PROMPT_PATTERN],
+        aliveTailLines: null,
+        shellPromptPatterns: [],
+        unreadableIsExited: true,
+        fatalPatterns: cli_patterns_1.CLAUDE_SESSION_ERROR_PATTERNS,
+        fatalRegexPatterns: cli_patterns_1.CLAUDE_SESSION_ERROR_REGEX_PATTERNS,
+    },
+    /**
+     * codex 0.149.1, the tool the Issue was reported against.
+     *
+     * `CODEX_PROMPT_PATTERN` (`^›`) is the composer AND the selected row of every
+     * numbered dialog, which is exactly the width wanted here: a pane parked on
+     * the trust / update / hooks-review dialog is a pane codex still owns.
+     * `CODEX_DIALOG_PATTERN` adds the dialogs whose selected row has scrolled out
+     * of the window, and the thinking pattern covers a turn in flight.
+     *
+     * Not `isCodexPromptReady`: that function answers "may I type into this?",
+     * which is a stricter question and false for every dialog above.
+     */
+    codex: {
+        ...SHARED,
+        ...ADDED_TOOL_DEFAULTS,
+        alivePatterns: [cli_patterns_1.CODEX_PROMPT_PATTERN, cli_patterns_1.CODEX_DIALOG_PATTERN, cli_patterns_1.CODEX_THINKING_PATTERN],
+    },
+    /**
+     * copilot 1.0.80.
+     *
+     * `COPILOT_PROMPT_PATTERN` is `^[>❯]\s`, which also matches the starship /
+     * pure / agnoster shell prompt (#1907 measured exactly that). Left in
+     * deliberately: it makes the verdict fail SAFE on those prompts — copilot is
+     * reported alive and nothing is relaunched — where dropping it would let a
+     * live composer be read as a shell.
+     */
+    copilot: {
+        ...SHARED,
+        ...ADDED_TOOL_DEFAULTS,
+        alivePatterns: [
+            cli_patterns_1.COPILOT_PROMPT_PATTERN,
+            cli_patterns_1.COPILOT_IDLE_STATUS_PATTERN,
+            cli_patterns_1.COPILOT_WORKING_STATUS_PATTERN,
+            cli_patterns_1.COPILOT_THINKING_PATTERN,
+        ],
+    },
+    /**
+     * opencode 1.18.23.
+     *
+     * `Ask anything...` is the HOME screen only — the composer of an opencode
+     * that has answered one turn is a bare gutter — so the placeholder cannot
+     * carry this on its own. The footer does: `OPENCODE_FOOTER_STATUS_PATTERN`
+     * (`8.9K (1%) · $`) is drawn on every frame after the first turn, and
+     * `OPENCODE_PROMPT_AFTER_RESPONSE` (`tab agents  ctrl+p commands`) on the
+     * frames before it. Both verified against
+     * `tests/fixtures/opencode-live-2049/{boot,two-turn}-idle-11822.txt`.
+     */
+    opencode: {
+        ...SHARED,
+        ...ADDED_TOOL_DEFAULTS,
+        alivePatterns: [
+            cli_patterns_1.OPENCODE_IDLE_COMPOSER_PATTERN,
+            cli_patterns_1.OPENCODE_PROMPT_AFTER_RESPONSE,
+            cli_patterns_1.OPENCODE_FOOTER_STATUS_PATTERN,
+            cli_patterns_1.OPENCODE_SELECTION_LIST_PATTERN,
+            cli_patterns_1.OPENCODE_THINKING_PATTERN,
+        ],
+    },
+    /**
+     * gemini 0.55.1.
+     *
+     * The composer and the braille spinner. gemini draws its dialogs inside a
+     * full-width rounded box, and box rows are deliberately NOT an alive pattern:
+     * gemini prints its session summary in the same box on the way OUT, so the
+     * exited pane still carries `╰────╯` two rows above the shell prompt
+     * (measured 2026-08-31). The length gate is what keeps a live gemini dialog
+     * alive — its rows are 200 columns wide.
+     */
+    gemini: {
+        ...SHARED,
+        ...ADDED_TOOL_DEFAULTS,
+        alivePatterns: [cli_patterns_1.GEMINI_PROMPT_PATTERN, cli_patterns_1.GEMINI_THINKING_PATTERN],
+    },
+    /** antigravity — patterns from `cli-patterns`; no live frames (not installed). */
+    antigravity: {
+        ...SHARED,
+        ...ADDED_TOOL_DEFAULTS,
+        alivePatterns: [
+            cli_patterns_1.ANTIGRAVITY_PROMPT_PATTERN,
+            cli_patterns_1.ANTIGRAVITY_SELECTION_LIST_PATTERN,
+            cli_patterns_1.ANTIGRAVITY_THINKING_PATTERN,
+        ],
+    },
+    /** vibe-local — patterns from `cli-patterns`; no live frames (needs Ollama). */
+    'vibe-local': {
+        ...SHARED,
+        ...ADDED_TOOL_DEFAULTS,
+        alivePatterns: [cli_patterns_1.VIBE_LOCAL_PROMPT_PATTERN, cli_patterns_1.VIBE_LOCAL_THINKING_PATTERN],
+    },
+};
+/**
+ * The liveness declaration for a CLI tool.
+ *
+ * @param cliToolId - CLI tool identifier
+ * @returns That tool's {@link ToolLivenessSpec}; claude's for an id outside
+ *   `CLI_TOOL_IDS` (a JavaScript caller or a cast). claude's is the
+ *   conservative fallback in the direction that matters: it is the one spec
+ *   whose verdicts have been in production since long before this Issue.
+ */
+function resolveLivenessSpec(cliToolId) {
+    return LIVENESS_SPECS[cliToolId] ?? LIVENESS_SPECS.claude;
+}

package/dist/server/src/lib/cli-tools/opencode.js

@@ -259,33 +259,74 @@ class OpenCodeTool extends base_1.BaseCLITool {
                 windowWidth: resolveOpencodePaneWidthChecked(),
                 windowHeight: tmux_pane_config_1.OPENCODE_PANE_HEIGHT,
             });
-            // Issue #1763: the pane outlived this process (a CommandMate restart), so
-            // the subscription that used to watch it is gone while its server is
-            // still listening. Recovered from the recorded port, health-checked, and
-            // skipped silently when there is nothing there. NOT a new generation —
-            // the pane is the same one, and fencing here would discard a still-valid
-            // verdict on every reconnect.
-            await (0, runtime_1.resumeOpencodeEventStream)(target, worktreePath);
-            logger.info('opencode-session-sessionname');
-            return;
+            // Issue #2070: is opencode still the thing drawing this pane? The two
+            // answers need DIFFERENT recovery, which is why the branch is here and
+            // not folded into the other tools' shape:
+            //
+            //  - **alive** — the pane outlived this CommandMate process (a restart),
+            //    the TUI's own HTTP server is still listening on the port it was
+            //    handed, and what is missing is only our subscription to it. Resume,
+            //    which recovers the RECORDED port.
+            //  - **exited** — the process that owned that port is gone, so the port
+            //    is not a thing to reconnect to; it is a number to hand out again.
+            //    Falling through takes the creation path's `reserveOpencodeServerPort`
+            //    → launch → `attachOpencodeEventStream`, which is the only sequence
+            //    that leaves the pane and the subscription agreeing about which
+            //    server they mean. Resuming here instead would attach to a port that
+            //    answers nothing — or, worse, to whatever process took it next, which
+            //    is the `port_identity_changed` hazard #1758 §5.9 exists for.
+            if (await this.isToolLive(sessionName, { confirm: true })) {
+                // Issue #1763: recovered from the recorded port, health-checked, and
+                // skipped silently when there is nothing there. NOT a new generation —
+                // the pane is the same one AND the process is the same process, so
+                // fencing here would discard a still-valid verdict on every reconnect.
+                await (0, runtime_1.resumeOpencodeEventStream)(target, worktreePath);
+                logger.info('opencode-session-sessionname');
+                return;
+            }
+            logger.warn('opencode-session-relaunch', { sessionName });
+            // Issue #2070: drop the dead process's stream and its port BEFORE the
+            // relaunch. Both are load-bearing, and neither is optional:
+            //
+            //  - `attachOpencodeEventStream` short-circuits on `isOpencodeSubscribed`,
+            //    so a subscription left over from the process that just died would
+            //    make the new one's attach a silent no-op and leave the pane on the
+            //    scraper for the rest of its life;
+            //  - `allocateOpencodePort` returns the IN-MEMORY assignment first, before
+            //    it checks anything, so without the release the relaunch would be
+            //    handed the dead server's number without ever asking whether it is
+            //    free. The persisted number is still preferred on re-allocation, so a
+            //    pane restarted in place keeps a stable port — see `ports.ts`.
+            //
+            // Never throws.
+            await (0, runtime_1.releaseOpencodeEventStream)(target);
         }
         // Issue #1759 (S8) / #1763: everything the previous opencode process
         // reported through this (worktreeId, instanceId) belongs to a session that
         // no longer exists, and the key is reused verbatim by the one about to be
-        // created. On the creation path only, before the pane exists, and even if
-        // the launch then fails — falling back to the scraper is always safe.
+        // created. Even if the launch then fails — falling back to the scraper is
+        // always safe.
+        //
+        // Issue #2070: reached on the RELAUNCH path too. The live-reuse branch above
+        // deliberately does NOT fence (same pane, same process); this one must
+        // (same pane, new process).
         (0, agent_session_lifecycle_1.beginAgentSession)(target);
         try {
             // Generate opencode.json if not present (non-fatal on failure)
             await (0, opencode_config_1.ensureOpencodeConfig)(worktreePath);
-            // Create tmux session. Scrollback depth comes from the shared
-            // TMUX_HISTORY_LIMIT default (Issue #1624) — do not re-hardcode it here.
-            await (0, tmux_1.createSession)({
-                sessionName,
-                workingDirectory: worktreePath,
-            });
-            // Wait a moment for the session to be created
-            await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.TUI_SESSION_CREATE_WAIT_MS));
+            // Issue #2070: creation only. On the relaunch path the pane already
+            // exists; the resize below still runs, because a pane that was created
+            // before #2047 carries the geometry of its own era either way.
+            if (!exists) {
+                // Create tmux session. Scrollback depth comes from the shared
+                // TMUX_HISTORY_LIMIT default (Issue #1624) — do not re-hardcode it here.
+                await (0, tmux_1.createSession)({
+                    sessionName,
+                    workingDirectory: worktreePath,
+                });
+                // Wait a moment for the session to be created
+                await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.TUI_SESSION_CREATE_WAIT_MS));
+            }
             // Resize tmux window so opencode's right-hand sidebar stays hidden and
             // `capture-pane` returns transcript rows only. Issue #2047 measured the
             // boundary this depends on (sidebar at >=121 columns, hidden at <=120) and
@@ -614,6 +655,18 @@ class OpenCodeTool extends base_1.BaseCLITool {
         if (!exists) {
             throw new Error(`OpenCode session ${sessionName} does not exist. Start the session first.`);
         }
+        // Issue #2070: the pane exists, but does the AGENT? An agent that quit,
+        // updated itself or crashed leaves its tmux session behind, and the send
+        // that followed used to sit in the readiness wait until it timed out —
+        // leaving `kill-session` by hand as the only recovery. Relaunches into the
+        // same pane when the tool is gone; costs one `capture-pane` when it is not.
+        //
+        // Before `trySendViaServer`, deliberately: when the TUI is gone so is the
+        // HTTP server it was, so the server path would fail and fall through to
+        // typing the message into a shell prompt. The relaunch reserves a port and
+        // re-attaches, so the server path is available again by the time it is
+        // tried. `sendMessageWithImage` reaches this through its own fallback.
+        await this.relaunchIfToolExited(worktreeId, instanceId);
         if (await this.trySendViaServer((0, runtime_1.opencodeTarget)(worktreeId, instanceId), message)) {
             // Issue #405: the transcript grew, so the cached capture is stale — the
             // same reason the keystroke path invalidates below.

package/dist/server/src/lib/cli-tools/session-liveness.js

@@ -0,0 +1,64 @@
+"use strict";
+/**
+ * The tmux round trip behind "did the tool exit?" (Issue #2070).
+ *
+ * Split from `lib/detection/tool-liveness`, which holds the rule and is pure,
+ * for the boundary §4 D4 draws: the detection layer never talks to a transport,
+ * and `src/lib/cli-tools/**` is one of the two places that may (`.eslintrc.json`
+ * `no-restricted-imports`). Putting the probe here is also what lets
+ * `BaseCLITool` use it without a cycle — the tool layer owns both the
+ * declaration and the reading of its own pane.
+ *
+ * @module lib/cli-tools/session-liveness
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.probeSessionLiveness = probeSessionLiveness;
+exports.probeToolSessionLiveness = probeToolSessionLiveness;
+const tmux_1 = require("../tmux/tmux");
+const tool_liveness_1 = require("../detection/tool-liveness");
+const liveness_spec_1 = require("./liveness-spec");
+/**
+ * Capture the bottom of a pane and decide whether the tool is still on it.
+ *
+ * Never throws. A capture that fails is handed to the spec as an unreadable
+ * frame, which claude has always called unhealthy (`capture error`) and every
+ * tool added by this Issue calls alive — see
+ * {@link ToolLivenessSpec.unreadableIsExited} for why the two answers differ.
+ *
+ * @param sessionName - tmux session name
+ * @param spec - The tool's liveness declaration
+ * @returns Whether the tool is there, and — when it is not — why not
+ */
+async function probeSessionLiveness(sessionName, spec) {
+    let output;
+    try {
+        output = await (0, tmux_1.capturePane)(sessionName, { startLine: -spec.probeCaptureLines });
+    }
+    catch {
+        output = undefined;
+    }
+    // `unknown` and re-checked rather than trusting the declared `Promise<string>`:
+    // this function's contract is that it never throws, and a transport that hands
+    // back a non-string (a stub, a JavaScript caller) must reach the spec's
+    // unreadable branch rather than a TypeError inside `stripAnsi`.
+    if (typeof output !== 'string') {
+        return spec.unreadableIsExited
+            ? { alive: false, reason: 'capture error' }
+            : { alive: true };
+    }
+    return (0, tool_liveness_1.judgeToolLiveness)(output, spec);
+}
+/**
+ * {@link probeSessionLiveness} for a tool named by id.
+ *
+ * The entry point for callers that hold a `CLIToolType` and must not
+ * instantiate the tool graph to ask one question — `worktree-status-helper`'s
+ * status poll is the reason it exists, exactly as `resolveCaptureSpec` is.
+ *
+ * @param sessionName - tmux session name
+ * @param cliToolId - CLI tool identifier
+ * @returns Whether the tool is there, and — when it is not — why not
+ */
+async function probeToolSessionLiveness(sessionName, cliToolId) {
+    return probeSessionLiveness(sessionName, (0, liveness_spec_1.resolveLivenessSpec)(cliToolId));
+}

package/dist/server/src/lib/cli-tools/vibe-local.js

@@ -63,18 +63,32 @@ class VibeLocalTool extends base_1.BaseCLITool {
         const exists = await (0, tmux_1.hasSession)(sessionName);
         if (exists) {
             await this.reconcileExistingSession(sessionName);
-            logger.info('vibe-local-session');
-            return;
+            // Issue #2070: this branch used to return unconditionally. A tmux session
+            // outlives the agent that was launched into it — a quit, a self-update, a
+            // crash — and the launch was then skipped for a pane holding nothing but a
+            // shell prompt, which left `kill-session` by hand as the only recovery.
+            // When the tool is gone we fall THROUGH and re-send the launch command
+            // into the same pane.
+            if (await this.isToolLive(sessionName, { confirm: true })) {
+                logger.info('vibe-local-session');
+                return;
+            }
+            logger.warn('vibe-local-session-relaunch', { sessionName });
         }
         try {
-            // Create tmux session. Scrollback depth comes from the shared
-            // TMUX_HISTORY_LIMIT default (Issue #1624) — do not re-hardcode it here.
-            await (0, tmux_1.createSession)({
-                sessionName,
-                workingDirectory: worktreePath,
-            });
-            // Wait a moment for the session to be created
-            await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.TUI_SESSION_CREATE_WAIT_MS));
+            // Issue #2070: creation only. On the relaunch path the pane already
+            // exists and holds the transcript of the process that died in it; the
+            // launch command is re-sent into that same pane.
+            if (!exists) {
+                // Create tmux session. Scrollback depth comes from the shared
+                // TMUX_HISTORY_LIMIT default (Issue #1624) — do not re-hardcode it here.
+                await (0, tmux_1.createSession)({
+                    sessionName,
+                    workingDirectory: worktreePath,
+                });
+                // Wait a moment for the session to be created
+                await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.TUI_SESSION_CREATE_WAIT_MS));
+            }
             // Read Ollama model and context window preferences from DB
             // [SEC-001] Re-validate model name at point of use (defense-in-depth)
             // [S1-005] DB direct access follows existing vibeLocalModel pattern;
@@ -121,6 +135,12 @@ class VibeLocalTool extends base_1.BaseCLITool {
         if (!exists) {
             throw new Error(`Vibe Local session ${sessionName} does not exist. Start the session first.`);
         }
+        // Issue #2070: the pane exists, but does the AGENT? An agent that quit,
+        // updated itself or crashed leaves its tmux session behind, and the send
+        // that followed used to sit in the readiness wait until it timed out —
+        // leaving `kill-session` by hand as the only recovery. Relaunches into the
+        // same pane when the tool is gone; costs one `capture-pane` when it is not.
+        await this.relaunchIfToolExited(worktreeId, instanceId);
         try {
             // Issue #1471: Body/Enter separation + read-back submit verification via the
             // shared helper. vibe-local's IME mode needs TWO Enter presses (first Enter