commandmate 0.44.1 → 0.44.3

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

@@ -57,6 +57,7 @@ const opencode_config_1 = require("./opencode-config");
 const tmux_pane_config_1 = require("../../config/tmux-pane-config");
 Object.defineProperty(exports, "OPENCODE_PANE_HEIGHT", { enumerable: true, get: function () { return tmux_pane_config_1.OPENCODE_PANE_HEIGHT; } });
 Object.defineProperty(exports, "OPENCODE_PANE_WIDTH", { enumerable: true, get: function () { return tmux_pane_config_1.OPENCODE_PANE_WIDTH; } });
+const opencode_pane_width_1 = require("./opencode-pane-width");
 const child_process_1 = require("child_process");
 const path_1 = require("path");
 const util_1 = require("util");
@@ -76,61 +77,11 @@ const install_hints_1 = require("./install-hints");
 const opencode_executable_1 = require("./opencode-executable");
 const log_diagnosis_1 = require("../../lib/hooks/sources/opencode/log-diagnosis");
 const launch_screen_1 = require("../../lib/session/launch-screen");
+const errors_1 = require("../../lib/errors");
 const logger = (0, logger_1.createLogger)('cli-tools/opencode');
 const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
-/**
- * Extract error message from unknown error type (DRY)
- * Same pattern as claude-session.ts / codex.ts / gemini.ts / vibe-local.ts.
- * A shared version exists in src/lib/errors.ts (getErrorMessage), but CLI tool
- * modules use local copies to avoid importing the server-side error module.
- * [D1-002] Future refactoring candidate: extract to BaseCLITool or a shared util.
- */
-function getErrorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}
 /** OpenCode TUI graceful exit command [D1-006] */
 exports.OPENCODE_EXIT_COMMAND = '/exit';
-/**
- * {@link resolveOpencodePaneWidth}, plus the one-line operator feedback the
- * pure config module deliberately cannot emit (Issue #2047).
- *
- * `tmux-pane-config.ts` has no imports at all — that is a documented property
- * (#1906), and pulling the logger in there would make every consumer of a
- * constant depend on the logging stack. So the resolver stays silent and the
- * warning lives here, at the two call sites that actually resize a pane.
- *
- * Two things are worth telling the operator, and neither is an error:
- *
- * - the value was DROPPED (not an integer, or outside the accepted bounds), so
- *   the pane they are about to look at is the 80-column default rather than
- *   what they asked for;
- * - the value was ACCEPTED but lands at or above
- *   {@link OPENCODE_SIDEBAR_MIN_WIDTH}, where opencode 1.18.22 paints its
- *   right-hand sidebar into the same rows as the transcript. #2047 measured
- *   what that does to this repo's own readers — a saved "reply" made entirely
- *   of sidebar chrome, a status flip on an aborted turn, and a false idle
- *   composer off the session title. It is still allowed, because an operator
- *   who only ever reads the pane in the browser may want it; it is not silent.
- *
- * @returns Pane width in columns, ready to hand to `resize-window`.
- */
-function resolveOpencodePaneWidthChecked() {
-    const requested = process.env[tmux_pane_config_1.OPENCODE_PANE_WIDTH_ENV];
-    const width = (0, tmux_pane_config_1.resolveOpencodePaneWidth)();
-    if (requested !== undefined && String(width) !== requested.trim()) {
-        logger.warn('opencode-pane-width-rejected', {
-            requested,
-            applied: width,
-        });
-    }
-    else if (width >= tmux_pane_config_1.OPENCODE_SIDEBAR_MIN_WIDTH) {
-        logger.warn('opencode-pane-width-sidebar-visible', {
-            width,
-            sidebarMinWidth: tmux_pane_config_1.OPENCODE_SIDEBAR_MIN_WIDTH,
-        });
-    }
-    return width;
-}
 /**
  * Interval between readiness polls while opencode paints its TUI (Issue #1908).
  *
@@ -238,13 +189,6 @@ class OpenCodeTool extends base_1.BaseCLITool {
     async isInstalled() {
         return (await (0, opencode_executable_1.resolveOpencodeV1Executable)()).executable !== null;
     }
-    /**
-     * Check if OpenCode session is running for a worktree
-     */
-    async isRunning(worktreeId, instanceId) {
-        const sessionName = this.getSessionName(worktreeId, instanceId);
-        return await (0, tmux_1.hasSession)(sessionName);
-    }
     /**
      * Start a new OpenCode session for a worktree
      * Launches `opencode` TUI in interactive mode within tmux
@@ -262,6 +206,9 @@ class OpenCodeTool extends base_1.BaseCLITool {
         }
         const sessionName = this.getSessionName(worktreeId, instanceId);
         const target = (0, runtime_1.opencodeTarget)(worktreeId, instanceId);
+        // Issue #3296: resolved ONCE. The relaunch path uses it twice (reconcile and
+        // resize), and resolving at each site printed the same warn twice.
+        const paneWidth = (0, opencode_pane_width_1.resolveOpencodePaneWidthChecked)({ warnSidebar: true });
         const exists = await (0, tmux_1.hasSession)(sessionName);
         if (exists) {
             // Issue #2047: the SAME width as the creation path below. These two used
@@ -270,7 +217,7 @@ class OpenCodeTool extends base_1.BaseCLITool {
             // a reconnect would silently hand the detectors a geometry the creation
             // path had been moved away from.
             await this.reconcileExistingSession(sessionName, worktreePath, {
-                windowWidth: resolveOpencodePaneWidthChecked(),
+                windowWidth: paneWidth,
                 windowHeight: tmux_pane_config_1.OPENCODE_PANE_HEIGHT,
             });
             // Issue #2070: is opencode still the thing drawing this pane? The two
@@ -295,7 +242,7 @@ class OpenCodeTool extends base_1.BaseCLITool {
                 // 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');
+                logger.info('opencode-session-exists');
                 return;
             }
             logger.warn('opencode-session-relaunch', { sessionName });
@@ -332,14 +279,7 @@ class OpenCodeTool extends base_1.BaseCLITool {
             // 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));
+                await this.createLaunchPane(sessionName, worktreePath);
             }
             // Resize tmux window so opencode's right-hand sidebar stays hidden and
             // `capture-pane` returns transcript rows only. Issue #2047 measured the
@@ -350,7 +290,7 @@ class OpenCodeTool extends base_1.BaseCLITool {
                 await execFileAsync('tmux', [
                     // Issue #1156: exact-match target so resize never leaks to a prefix-colliding instance
                     'resize-window', '-t', (0, tmux_1.exactTarget)(sessionName),
-                    '-x', String(resolveOpencodePaneWidthChecked()), '-y', String(tmux_pane_config_1.OPENCODE_PANE_HEIGHT),
+                    '-x', String(paneWidth), '-y', String(tmux_pane_config_1.OPENCODE_PANE_HEIGHT),
                 ]);
             }
             catch {
@@ -419,10 +359,10 @@ class OpenCodeTool extends base_1.BaseCLITool {
                     throw new Error((0, log_diagnosis_1.buildOpencodeSharedDataConflictMessage)(conflict));
                 }
             }
-            logger.info('started-opencode-session:sessionname');
+            logger.info('started-opencode-session');
         }
         catch (error) {
-            const errorMessage = getErrorMessage(error);
+            const errorMessage = (0, errors_1.getErrorMessage)(error);
             throw new Error(`Failed to start OpenCode session: ${errorMessage}`);
         }
     }
@@ -625,7 +565,7 @@ class OpenCodeTool extends base_1.BaseCLITool {
             logger.warn('opencode-send-api-failed', {
                 worktreeId: target.worktreeId,
                 instanceId,
-                error: getErrorMessage(error),
+                error: (0, errors_1.getErrorMessage)(error),
             });
             return false;
         }
@@ -676,10 +616,6 @@ class OpenCodeTool extends base_1.BaseCLITool {
      */
     async sendMessage(worktreeId, message, instanceId) {
         const sessionName = this.getSessionName(worktreeId, instanceId);
-        const exists = await (0, tmux_1.hasSession)(sessionName);
-        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 —
@@ -691,7 +627,7 @@ class OpenCodeTool extends base_1.BaseCLITool {
         // 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);
+        await this.requireSession('OpenCode', worktreeId, instanceId, { relaunch: true });
         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.
@@ -709,10 +645,10 @@ class OpenCodeTool extends base_1.BaseCLITool {
             });
             // Issue #405: Invalidate cache after sending message
             (0, tmux_capture_cache_1.invalidateCache)(sessionName);
-            logger.info('sent-message-to-opencode-session:session');
+            logger.info('sent-message-to-opencode-session');
         }
         catch (error) {
-            const errorMessage = getErrorMessage(error);
+            const errorMessage = (0, errors_1.getErrorMessage)(error);
             throw new Error(`Failed to send message to OpenCode: ${errorMessage}`);
         }
     }
@@ -756,10 +692,7 @@ class OpenCodeTool extends base_1.BaseCLITool {
      */
     async sendMessageWithImage(worktreeId, message, imagePath, instanceId) {
         const sessionName = this.getSessionName(worktreeId, instanceId);
-        const exists = await (0, tmux_1.hasSession)(sessionName);
-        if (!exists) {
-            throw new Error(`OpenCode session ${sessionName} does not exist. Start the session first.`);
-        }
+        await this.requireSession('OpenCode', worktreeId, instanceId, { relaunch: false });
         const target = (0, runtime_1.opencodeTarget)(worktreeId, instanceId);
         if (await this.trySendViaServer(target, message, imagePath)) {
             (0, tmux_capture_cache_1.invalidateCache)(sessionName);
@@ -869,10 +802,13 @@ class OpenCodeTool extends base_1.BaseCLITool {
             }
             // Issue #405: Invalidate cache after session kill
             (0, tmux_capture_cache_1.invalidateCache)(sessionName);
-            logger.info('stopped-opencode-session:sessionname');
+            // Logged unconditionally: after a successful `/exit` no tmux kill runs, so
+            // there is no `killed` value to test, unlike `requestExitAndKill` in
+            // base.ts (logs only when the kill returned true) (#3232).
+            logger.info('stopped-opencode-session');
         }
         catch (error) {
-            logger.error('session:stop-failed', { error: getErrorMessage(error) });
+            logger.error('session:stop-failed', { error: (0, errors_1.getErrorMessage)(error) });
             throw error;
         }
     }

package/dist/server/src/lib/cli-tools/submit-verified-sender.js

@@ -67,6 +67,18 @@
  * bracketed paste, which the TUI reads as a unit), and Enter is withheld until
  * the composer shows the whole of it ({@link classifyPasteLanded}). The
  * measurements are in `docs/design/2464-long-body-repro-matrix.md`.
+ *
+ * Issue #3366 is the Enter arriving before the body on codex. codex 0.160.0
+ * holds fast keystrokes back as a "paste burst" and draws them only once the
+ * burst is over — measured at 200x1000: 34 characters after ~180 ms, 80 after
+ * ~380 ms, 135 after ~630 ms, 539 after ~2.2 s — and an Enter that lands inside
+ * the burst becomes a newline in the composer. The old fixed 100 ms wait pressed
+ * Enter there, and the read-back 200 ms later still saw the idle placeholder
+ * (the body had not been drawn yet), which it read as "the message left the
+ * box": `Message sent.`, with the body sitting unsent in the composer. So for
+ * codex, Enter now waits until the composer shows the typed body
+ * ({@link confirmTypedBodyLanded}); a body that never appears THROWS before
+ * Enter, as #2464 does for a paste.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -116,6 +128,7 @@ const cli_patterns_1 = require("../detection/cli-patterns");
 const cli_tool_timing_config_1 = require("../../config/cli-tool-timing-config");
 const logger_1 = require("../../lib/logger");
 const composer_clear_1 = require("../../lib/session/composer-clear");
+const composer_text_1 = require("../../lib/detection/composer-text");
 const logger = (0, logger_1.createLogger)('cli-tools/submit-verified-sender');
 /**
  * Version-resilient pasted-text placeholder.
@@ -149,6 +162,20 @@ exports.LITERAL_SEND_MAX_BYTES = 512;
 const PASTE_LANDED_POLL_MS = 100;
 /** Composer reads before a paste that has not fully appeared is abandoned (2 s). */
 const DEFAULT_PASTE_LANDED_ATTEMPTS = 20;
+/**
+ * How often the composer is read while a TYPED body is expected to appear in it
+ * (Issue #3366). codex draws a burst of keystrokes all at once when the burst
+ * ends, so the poll only decides how late after that moment Enter goes in.
+ */
+const TYPED_BODY_POLL_MS = 50;
+/**
+ * Composer reads before a typed body that has not appeared is abandoned (5 s).
+ *
+ * codex 0.160.0 drew a 539-character body ~2.2 s after `send-keys` — about 4 ms
+ * per character — and a typed body is at most {@link LITERAL_SEND_MAX_BYTES},
+ * so this is roughly twice the slowest draw measured, for a loaded machine.
+ */
+const DEFAULT_TYPED_BODY_ATTEMPTS = 100;
 /** Per-command timeout for `load-buffer` / `paste-buffer`, as for every other tmux call. */
 const PASTE_COMMAND_TIMEOUT_MS = 5000;
 /** Makes each send's tmux paste buffer name unique within this process. */
@@ -384,6 +411,32 @@ function comparePasteToken(token, message) {
         return 'landed';
     return observed < Math.min(...accepted) ? 'pasting' : 'mismatch';
 }
+/**
+ * The composer as {@link classifySubmit} reads it (Issue #3205).
+ *
+ * {@link readComposer}'s marker reader takes the bottom-most `›` row of the
+ * tail as the input line. A codex composer holding several lines draws its
+ * continuation rows under the `›` row, and when one of them itself begins with
+ * `›` — a body quoting a dialog's `› 1. Yes, proceed (y)` — that continuation
+ * row was read as the input line: its text is not the body's first line, so a
+ * body still sitting in the composer was classified `submitted` (F). Measured:
+ * `tests/fixtures/codex-multiline-composer-3205/tc104-raw-pane.txt`.
+ *
+ * So for codex a composer of two or more rows is read with
+ * `extractComposerText` — the #1890 reader `awaitTypedBody` already uses —
+ * and its first line is the input line. Every other frame (a one-row
+ * composer, an empty or ghost one, none at all, another tool) is read exactly
+ * as before.
+ */
+function readSubmitComposer(output, cliToolId, reader, lines, windowLines) {
+    if (cliToolId === 'codex' && reader === 'input-line-marker') {
+        const read = (0, composer_text_1.extractComposerText)(output, cliToolId);
+        if (read.state === 'content' && read.text.includes('\n')) {
+            return { kind: 'text', text: firstNonBlankLine(read.text), rows: read.text.split('\n') };
+        }
+    }
+    return readComposer(reader, lines, windowLines);
+}
 /**
  * Classify a captured pane into submitted / pending / replaced (Issue #1501).
  *
@@ -428,7 +481,7 @@ function classifySubmit(output, cliToolId, message, composerSpec = (0, composer_
     if ((0, cli_patterns_1.detectThinking)(cliToolId, windowStr)) {
         return 'submitted';
     }
-    const composer = readComposer(composerSpec.reader, lines, windowLines);
+    const composer = readSubmitComposer(output, cliToolId, composerSpec.reader, lines, windowLines);
     // B. No composer visible (scrolled off / dialog / still starting), or the
     //    composer is empty => the message left the box => submitted.
     if (composer.kind !== 'text') {
@@ -625,6 +678,66 @@ async function confirmPasteLanded(params) {
     throw new Error(`Message body did not arrive intact for session ${sessionName}: ${what}; the message is ${bytes} bytes / ${lineCount} lines. ` +
         'Enter was not pressed, so nothing was submitted (Issue #2464).');
 }
+/** The text with every whitespace character removed — wrapping and indent proof. */
+function compactText(text) {
+    return text.replace(/\s+/g, '');
+}
+/**
+ * The part of a typed body the composer reader can see (Issue #3366).
+ *
+ * The codex reader takes the composer as one run of non-blank rows, so a blank
+ * line inside the body ends what it returns: what it can show is the body up to
+ * its first blank line after the first non-blank one. Leading blank lines are
+ * kept — they are drawn as composer rows of their own and compact to nothing.
+ */
+function visibleTypedBody(message) {
+    const lines = message.split('\n');
+    const first = lines.findIndex((line) => line.trim() !== '');
+    if (first < 0)
+        return '';
+    const blank = lines.findIndex((line, index) => index > first && line.trim() === '');
+    return lines.slice(0, blank < 0 ? lines.length : blank).join('\n');
+}
+/**
+ * Wait until the composer shows the typed body; only then may Enter be pressed
+ * (Issue #3366).
+ *
+ * codex 0.160.0 keeps fast keystrokes in a "paste burst" and inserts them in
+ * one go when the burst ends, which took ~4 ms per character at 200x1000
+ * (`tests/fixtures/codex-send-burst-3366/`). Until then the composer shows its
+ * dim `Ask Codex to do anything`, and an Enter that lands in the burst becomes a
+ * newline under the body. The verdict is therefore "the composer's real (not
+ * dim) text is the body", read with `extractComposerText`, and nothing less:
+ * a prefix is not enough, because codex can draw the first keystrokes before it
+ * decides the rest are a burst.
+ *
+ * A body that never appears is taken back out and the send THROWS without
+ * Enter — nothing was submitted, so the caller must not print `Message sent.`.
+ *
+ * @throws Error when the composer does not show the body within the attempts
+ */
+async function confirmTypedBodyLanded(params) {
+    const { sessionName, message, cliToolId, composer, attempts } = params;
+    const expected = compactText(visibleTypedBody(message));
+    if (expected === '')
+        return;
+    let output = '';
+    for (let attempt = 0; attempt < Math.max(1, attempts); attempt++) {
+        await new Promise((resolve) => setTimeout(resolve, TYPED_BODY_POLL_MS));
+        output = await (0, tmux_1.capturePane)(sessionName, { startLine: -composer.verifyCaptureLines });
+        const read = (0, composer_text_1.extractComposerText)(output, cliToolId);
+        if (read.state === 'content' && compactText(read.text) === expected)
+            return;
+    }
+    const bytes = Buffer.byteLength(message, 'utf8');
+    const shown = describeComposer(output, composer);
+    await withdrawUnsentBody(sessionName, cliToolId, composer);
+    (0, tmux_capture_cache_1.invalidateCache)(sessionName);
+    logger.error('typed-body-not-landed', { sessionName, cliToolId, bytes, attempts, shown });
+    throw new Error(`Message body did not appear in the composer for session ${sessionName} within ` +
+        `${attempts * TYPED_BODY_POLL_MS}ms (it shows ${shown}); the message is ${bytes} bytes. ` +
+        'Enter was not pressed, so nothing was submitted (Issue #3366).');
+}
 /**
  * Empty the composer before the body is typed into it (Issue #1880).
  *
@@ -719,7 +832,7 @@ async function clearComposerBeforeSend(sessionName, cliToolId, composerSpec = (0
  *   confirmed within the bounded attempts.
  */
 async function sendMessageWithSubmitVerification(params) {
-    const { sessionName, message, cliToolId, composer = (0, composer_spec_1.resolveComposerSpec)(cliToolId), textInputWaitMs = cli_tool_timing_config_1.TUI_TEXT_INPUT_WAIT_MS, interEnterWaitMs = cli_tool_timing_config_1.TUI_TEXT_INPUT_WAIT_MS, verifyAttempts = DEFAULT_VERIFY_ATTEMPTS, verifyDelayMs = cli_tool_timing_config_1.TUI_MESSAGE_PROCESSED_WAIT_MS, pasteLandedAttempts = DEFAULT_PASTE_LANDED_ATTEMPTS, } = params;
+    const { sessionName, message, cliToolId, composer = (0, composer_spec_1.resolveComposerSpec)(cliToolId), textInputWaitMs = cli_tool_timing_config_1.TUI_TEXT_INPUT_WAIT_MS, interEnterWaitMs = cli_tool_timing_config_1.TUI_TEXT_INPUT_WAIT_MS, verifyAttempts = DEFAULT_VERIFY_ATTEMPTS, verifyDelayMs = cli_tool_timing_config_1.TUI_MESSAGE_PROCESSED_WAIT_MS, pasteLandedAttempts = DEFAULT_PASTE_LANDED_ATTEMPTS, awaitTypedBody = false, typedBodyAttempts = DEFAULT_TYPED_BODY_ATTEMPTS, } = params;
     const submitEnterCount = params.submitEnterCount ?? composer.submitEnterCount;
     // 0. Empty the composer first (Issue #1880). The body below is typed at the
     //    TUI's current cursor position, so anything already in the box would be
@@ -748,9 +861,19 @@ async function sendMessageWithSubmitVerification(params) {
         //    sent SIGINT — and a body starting with `-` was eaten by getopt and sent
         //    nowhere at all, with `rc 0`. All four measured on tmux 3.5a; the argv is
         //    built in `lib/tmux/key-sequence.ts`, which carries the table.
+        const typedAt = Date.now();
         await (0, tmux_1.sendKeys)(sessionName, message, false, { literal: true });
-        // 2. Let the TUI register the input before pressing Enter.
-        await new Promise((resolve) => setTimeout(resolve, textInputWaitMs));
+        // 2. Let the TUI register the input before pressing Enter. On codex that
+        //    means waiting until the body is drawn (Issue #3366): an Enter pressed
+        //    while codex still holds the keystrokes as a paste burst becomes a
+        //    newline, and the body stays unsent. The fixed wait stays as a floor.
+        if (awaitTypedBody && composer_text_1.SUPPORTED_COMPOSER_TOOLS.has(cliToolId)) {
+            await confirmTypedBodyLanded({ sessionName, message, cliToolId, composer, attempts: typedBodyAttempts });
+        }
+        const remaining = textInputWaitMs - (Date.now() - typedAt);
+        if (remaining > 0) {
+            await new Promise((resolve) => setTimeout(resolve, remaining));
+        }
     }
     // 3. Submit as a separate command (double Enter for vibe-local's IME mode).
     for (let i = 0; i < Math.max(1, submitEnterCount); i++) {

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

@@ -19,16 +19,10 @@ const db_instance_1 = require("../db/db-instance");
 const db_1 = require("../db");
 const logger_1 = require("../../lib/logger");
 const cli_tool_timing_config_1 = require("../../config/cli-tool-timing-config");
-const install_hints_1 = require("./install-hints");
 const agent_session_lifecycle_1 = require("../../lib/session/agent-session-lifecycle");
 const launch_screen_1 = require("../../lib/session/launch-screen");
+const errors_1 = require("../../lib/errors");
 const logger = (0, logger_1.createLogger)('cli-tools/vibe-local');
-/**
- * Extract error message from unknown error type (DRY)
- */
-function getErrorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}
 /**
  * Wait for vibe-local to initialize after launch.
  * vibe-local shows a permission check prompt, banner, and model loading.
@@ -42,13 +36,6 @@ class VibeLocalTool extends base_1.BaseCLITool {
     id = 'vibe-local';
     name = 'Vibe Local';
     command = 'vibe-local';
-    /**
-     * Check if vibe-local session is running for a worktree
-     */
-    async isRunning(worktreeId, instanceId) {
-        const sessionName = this.getSessionName(worktreeId, instanceId);
-        return await (0, tmux_1.hasSession)(sessionName);
-    }
     /**
      * Start a new vibe-local session for a worktree
      * Launches `vibe-local -y` in interactive mode within tmux
@@ -57,26 +44,14 @@ class VibeLocalTool extends base_1.BaseCLITool {
      * @param worktreePath - Worktree path
      */
     async launchSession(worktreeId, worktreePath, instanceId) {
-        const vibeLocalAvailable = await this.isInstalled();
-        if (!vibeLocalAvailable) {
-            throw (0, install_hints_1.missingToolError)(this);
-        }
-        const sessionName = this.getSessionName(worktreeId, instanceId);
-        const exists = await (0, tmux_1.hasSession)(sessionName);
-        if (exists) {
-            await this.reconcileExistingSession(sessionName, worktreePath);
-            // 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 });
-        }
+        await this.requireInstalled();
+        const { sessionName, exists, live } = await this.resolveLaunchPane(worktreeId, worktreePath, instanceId, {
+            logger,
+            liveAction: 'vibe-local-session-exists',
+            relaunchAction: 'vibe-local-session-relaunch',
+        });
+        if (live)
+            return;
         // Issue #1759 / #2444: the one line every tool's creation path owes the
         // rest of the system. vibe-local emits no structured events, so the
         // generation fence itself is inert here — but `beginAgentSession` is also
@@ -91,14 +66,7 @@ class VibeLocalTool extends base_1.BaseCLITool {
             // 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));
+                await this.createLaunchPane(sessionName, worktreePath);
             }
             // Read Ollama model and context window preferences from DB
             // [SEC-001] Re-validate model name at point of use (defense-in-depth)
@@ -127,10 +95,10 @@ class VibeLocalTool extends base_1.BaseCLITool {
             await (0, tmux_1.sendKeys)(sessionName, (0, launch_screen_1.withLaunchScreenCleared)(vibeLocalCommand), true);
             // Wait for vibe-local to initialize (banner + model loading)
             await new Promise((resolve) => setTimeout(resolve, VIBE_LOCAL_INIT_WAIT_MS));
-            logger.info('started-vibe-local-session:sessionname');
+            logger.info('started-vibe-local-session');
         }
         catch (error) {
-            const errorMessage = getErrorMessage(error);
+            const errorMessage = (0, errors_1.getErrorMessage)(error);
             throw new Error(`Failed to start Vibe Local session: ${errorMessage}`);
         }
     }
@@ -142,16 +110,12 @@ class VibeLocalTool extends base_1.BaseCLITool {
      */
     async sendMessage(worktreeId, message, instanceId) {
         const sessionName = this.getSessionName(worktreeId, instanceId);
-        const exists = await (0, tmux_1.hasSession)(sessionName);
-        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);
+        await this.requireSession('Vibe Local', worktreeId, instanceId, { relaunch: true });
         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
@@ -169,10 +133,10 @@ class VibeLocalTool extends base_1.BaseCLITool {
             });
             // Issue #405: Invalidate cache after sending message
             (0, tmux_capture_cache_1.invalidateCache)(sessionName);
-            logger.info('sent-message-to-vibe-local-session:sessi');
+            logger.info('sent-message-to-vibe-local-session');
         }
         catch (error) {
-            const errorMessage = getErrorMessage(error);
+            const errorMessage = (0, errors_1.getErrorMessage)(error);
             throw new Error(`Failed to send message to Vibe Local: ${errorMessage}`);
         }
     }
@@ -182,27 +146,18 @@ class VibeLocalTool extends base_1.BaseCLITool {
      * @param worktreeId - Worktree ID
      */
     async killSession(worktreeId, instanceId) {
-        const sessionName = this.getSessionName(worktreeId, instanceId);
-        try {
-            const exists = await (0, tmux_1.hasSession)(sessionName);
-            if (exists) {
+        await this.requestExitAndKill(worktreeId, instanceId, {
+            logger,
+            stoppedAction: 'stopped-vibe-local-session',
+            requestExit: async (sessionName) => {
                 // Send Ctrl+C to interrupt any running operation
                 await (0, tmux_1.sendSpecialKey)(sessionName, 'C-c');
                 await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.TUI_INTERRUPT_SETTLE_MS));
                 // Send Ctrl+C again to ensure exit
                 await (0, tmux_1.sendSpecialKey)(sessionName, 'C-c');
                 await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.TUI_EXIT_WAIT_MS));
-            }
-            // Kill the tmux session
-            const killed = await (0, tmux_1.killSession)(sessionName);
-            if (killed) {
-                logger.info('stopped-vibe-local-session:sessionname');
-            }
-        }
-        catch (error) {
-            logger.error('session:stop-failed', { error: getErrorMessage(error) });
-            throw error;
-        }
+            },
+        });
     }
 }
 exports.VibeLocalTool = VibeLocalTool;