commandmate 0.44.1 → 0.44.3

package/dist/server/src/lib/cli-tools/command-code.js

@@ -50,7 +50,6 @@ const logger_1 = require("../../lib/logger");
 const tool_id_1 = require("../../lib/hooks/sources/command-code/tool-id");
 const agent_session_lifecycle_1 = require("../../lib/session/agent-session-lifecycle");
 const cli_tool_timing_config_1 = require("../../config/cli-tool-timing-config");
-const install_hints_1 = require("./install-hints");
 const plan_review_state_1 = require("../detection/tools/command-code/plan-review-state");
 const session_start_error_1 = require("../../lib/session/session-start-error");
 const launch_screen_1 = require("../../lib/session/launch-screen");
@@ -202,17 +201,6 @@ class CommandCodeTool extends base_1.BaseCLITool {
     navigationKeys() {
         return { keys: terminal_keys_1.COMMAND_CODE_NAVIGATION_KEY_VALUES, leaderKey: null };
     }
-    /**
-     * Check if a Command Code session is running for a worktree.
-     *
-     * @param worktreeId - Worktree ID
-     * @param instanceId - Agent instance ID (defaults to the primary instance)
-     * @returns True if session is running
-     */
-    async isRunning(worktreeId, instanceId) {
-        const sessionName = this.getSessionName(worktreeId, instanceId);
-        return await (0, tmux_1.hasSession)(sessionName);
-    }
     /**
      * Start a new Command Code session for a worktree.
      *
@@ -221,23 +209,17 @@ class CommandCodeTool extends base_1.BaseCLITool {
      * @param instanceId - Agent instance ID (defaults to the primary instance)
      */
     async launchSession(worktreeId, worktreePath, instanceId) {
-        const available = await this.isInstalled();
-        if (!available) {
-            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's shape: a tmux session outlives the agent that was launched
-            // into it, and skipping the launch for a pane holding nothing but a shell
-            // prompt leaves `kill-session` by hand as the only recovery.
-            if (await this.isToolLive(sessionName, { confirm: true })) {
-                logger.info('command-code-session-exists');
-                return;
-            }
-            logger.warn('command-code-session-relaunch', { sessionName });
-        }
+        await this.requireInstalled();
+        // Issue #2070's shape: a tmux session outlives the agent that was launched
+        // into it, and skipping the launch for a pane holding nothing but a shell
+        // prompt leaves `kill-session` by hand as the only recovery.
+        const { sessionName, exists, live } = await this.resolveLaunchPane(worktreeId, worktreePath, instanceId, {
+            logger,
+            liveAction: 'command-code-session-exists',
+            relaunchAction: 'command-code-session-relaunch',
+        });
+        if (live)
+            return;
         // Issue #2251, seam S8: fence this instance's structured events off from the
         // process that used to hold the same (worktree, tool, instance) key. On the
         // creation path and on #2070's relaunch path — the reuse branch above has
@@ -253,11 +235,7 @@ class CommandCodeTool extends base_1.BaseCLITool {
             if (!exists) {
                 // Inline-rendered, so the pane keeps scrollback; depth comes from the
                 // shared TMUX_HISTORY_LIMIT default (Issue #1624).
-                await (0, tmux_1.createSession)({
-                    sessionName,
-                    workingDirectory: worktreePath,
-                });
-                await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.TUI_SESSION_CREATE_WAIT_MS));
+                await this.createLaunchPane(sessionName, worktreePath);
             }
             await (0, tmux_1.sendKeys)(sessionName, (0, launch_screen_1.withLaunchScreenCleared)(buildCommandCodeLaunchCommand({
                 target: { worktreeId, cliToolId: tool_id_1.COMMAND_CODE_CLI_TOOL_ID, instanceId },
@@ -367,13 +345,9 @@ class CommandCodeTool 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(`Command Code session ${sessionName} does not exist. Start the session first.`);
-        }
         // Issue #2070: the pane exists, but does the AGENT? 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('Command Code', worktreeId, instanceId, { relaunch: true });
         try {
             await this.waitForPrompt(sessionName);
             // Issue #1471: body/Enter separation + read-back submit verification.
@@ -407,27 +381,21 @@ class CommandCodeTool extends base_1.BaseCLITool {
      * @param instanceId - Agent instance ID (defaults to the primary instance)
      */
     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-command-code-session',
+            requestExit: async (sessionName) => {
                 await (0, tmux_1.sendKeys)(sessionName, exports.COMMAND_CODE_EXIT_COMMAND, false);
                 await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.TUI_TEXT_INPUT_WAIT_MS));
                 await (0, tmux_1.sendSpecialKeys)(sessionName, ['Enter']);
                 await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.TUI_EXIT_WAIT_MS));
-            }
-            const killed = await (0, tmux_1.killSession)(sessionName);
-            this.composerPendingSince.delete(sessionName);
-            // So a later session reusing the name starts clean.
-            (0, tmux_capture_cache_1.invalidateCache)(sessionName);
-            if (killed) {
-                logger.info('stopped-command-code-session');
-            }
-        }
-        catch (error) {
-            logger.error('session:stop-failed', { error: (0, errors_1.getErrorMessage)(error) });
-            throw error;
-        }
+            },
+            afterKill: (sessionName) => {
+                this.composerPendingSince.delete(sessionName);
+                // So a later session reusing the name starts clean.
+                (0, tmux_capture_cache_1.invalidateCache)(sessionName);
+            },
+        });
     }
 }
 exports.CommandCodeTool = CommandCodeTool;

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

@@ -278,16 +278,6 @@ class CopilotTool extends base_1.BaseCLITool {
     launchExecutable(resolved) {
         return resolved.source === 'path' ? this.command : hook_settings_1.COPILOT_LAUNCH_COMMAND;
     }
-    /**
-     * Check if Copilot session is running for a worktree
-     *
-     * @param worktreeId - Worktree ID
-     * @returns True if session is running
-     */
-    async isRunning(worktreeId, instanceId) {
-        const sessionName = this.getSessionName(worktreeId, instanceId);
-        return await (0, tmux_1.hasSession)(sessionName);
-    }
     /**
      * Start a new Copilot session for a worktree
      * Launches copilot in interactive mode within tmux
@@ -304,23 +294,13 @@ class CopilotTool extends base_1.BaseCLITool {
         if (!resolved) {
             throw (0, install_hints_1.missingToolError)(this);
         }
-        const sessionName = this.getSessionName(worktreeId, instanceId);
-        // Check if session already exists
-        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('copilot-session-exists');
-                return;
-            }
-            logger.warn('copilot-session-relaunch', { sessionName });
-        }
+        const { sessionName, exists, live } = await this.resolveLaunchPane(worktreeId, worktreePath, instanceId, {
+            logger,
+            liveAction: 'copilot-session-exists',
+            relaunchAction: 'copilot-session-relaunch',
+        });
+        if (live)
+            return;
         // Issue #1761: fence this session off from the previous copilot process's
         // events. The state is keyed by (worktree, tool, instance), a key the new
         // session reuses verbatim, so without this the old process's last
@@ -338,19 +318,6 @@ class CopilotTool extends base_1.BaseCLITool {
         // the new one's.
         (0, agent_session_lifecycle_1.beginAgentSession)({ worktreeId, cliToolId: tool_id_1.COPILOT_CLI_TOOL_ID, instanceId });
         try {
-            // 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));
-            }
             // Issue #1761: hand this session its hook configuration, so structured
             // lifecycle events and Auto-Yes adjudication exist without the operator
             // having edited ~/.copilot/settings.json by hand.
@@ -363,12 +330,21 @@ class CopilotTool extends base_1.BaseCLITool {
             //
             // Fails open in every branch: with `CM_AGENT_HOOKS_INJECT=0`, or with a
             // settings file that cannot be read or written, this is the bare launch
-            // command and nothing else.
+            // command and nothing else. The one exception is UAT isolation (Issue
+            // #3391), where the plan throws instead — which is why it is built BEFORE
+            // the tmux session: a refused launch must not leave an empty pane that
+            // `isRunning()` reports as a started copilot.
             const launchCommand = (0, agent_session_lifecycle_1.buildAgentLaunchCommandLine)({
                 target: { worktreeId, cliToolId: tool_id_1.COPILOT_CLI_TOOL_ID, instanceId },
                 executablePath: this.launchExecutable(resolved),
                 worktreePath,
             });
+            // 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) {
+                await this.createLaunchPane(sessionName, worktreePath);
+            }
             // Start Copilot CLI in interactive mode
             await (0, tmux_1.sendKeys)(sessionName, (0, launch_screen_1.withLaunchScreenCleared)(launchCommand), true);
             // Issue #1907: no blind sleep before this. The 4-second one that used to
@@ -647,17 +623,12 @@ class CopilotTool extends base_1.BaseCLITool {
      */
     async sendMessage(worktreeId, message, instanceId) {
         const sessionName = this.getSessionName(worktreeId, instanceId);
-        // Check if session exists
-        const exists = await (0, tmux_1.hasSession)(sessionName);
-        if (!exists) {
-            throw new Error(`Copilot 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('Copilot', worktreeId, instanceId, { relaunch: true });
         try {
             // Verify Copilot is at prompt state before sending
             await this.waitForPrompt(sessionName);
@@ -747,11 +718,7 @@ class CopilotTool extends base_1.BaseCLITool {
      */
     async sendModelCommand(worktreeId, modelName, instanceId) {
         const sessionName = this.getSessionName(worktreeId, instanceId);
-        // Check if session exists
-        const exists = await (0, tmux_1.hasSession)(sessionName);
-        if (!exists) {
-            throw new Error(`Copilot session ${sessionName} does not exist. Start the session first.`);
-        }
+        await this.requireSession('Copilot', worktreeId, instanceId, { relaunch: false });
         try {
             const idle = await this.waitForPrompt(sessionName, copilot_constants_1.COPILOT_MODEL_SWITCH_TIMEOUT_MS, 'idle');
             if (!idle.ready) {
@@ -828,10 +795,10 @@ class CopilotTool extends base_1.BaseCLITool {
      * @param instanceId - Optional agent instance ID (defaults to primary)
      */
     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-copilot-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));
@@ -840,17 +807,8 @@ class CopilotTool extends base_1.BaseCLITool {
                 await new Promise((resolve) => setTimeout(resolve, copilot_constants_1.COPILOT_TEXT_INPUT_DELAY_MS));
                 await (0, tmux_1.sendSpecialKeys)(sessionName, ['Enter']);
                 await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.COPILOT_EXIT_WAIT_MS));
-            }
-            // Kill the tmux session
-            const killed = await (0, tmux_1.killSession)(sessionName);
-            if (killed) {
-                logger.info('stopped-copilot-session');
-            }
-        }
-        catch (error) {
-            logger.error('session:stop-failed', { error: (0, errors_1.getErrorMessage)(error) });
-            throw error;
-        }
+            },
+        });
     }
 }
 exports.CopilotTool = CopilotTool;

package/dist/server/src/lib/cli-tools/direct-input.js

@@ -7,6 +7,14 @@
  * grow `ICLITool` either — every hand-written `ICLITool` in the test suite would
  * stop type-checking. So the route calls this one function, which lives inside
  * the CLITool gateway and is therefore allowed to reach the transport.
+ *
+ * Issue #3290: this function finds the session by NAME and sends. Whether the
+ * session is this server's is not decided here — it takes no worktree path to
+ * compare `#{session_path}` with — so the caller has to have asked
+ * `checkSessionOwnership` first, as the route does. A caller that skips it types
+ * into whichever server owns the name;
+ * `tests/unit/guards/worktree-route-session-ownership-3290.test.ts` fails a
+ * worktree route that does.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sendDirectInput = sendDirectInput;

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

@@ -21,15 +21,9 @@ const sources_1 = require("../../lib/hooks/sources");
 const agent_session_lifecycle_1 = require("../../lib/session/agent-session-lifecycle");
 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 launch_screen_1 = require("../../lib/session/launch-screen");
+const errors_1 = require("../../lib/errors");
 const logger = (0, logger_1.createLogger)('cli-tools/gemini');
-/**
- * Extract error message from unknown error type (DRY)
- */
-function getErrorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}
 /** Wait for Gemini CLI to initialize after launch (banner + auth + dialog) */
 const GEMINI_INIT_WAIT_MS = 6000;
 /** Interval for polling trust dialog / prompt detection */
@@ -46,16 +40,6 @@ class GeminiTool extends base_1.BaseCLITool {
     id = 'gemini';
     name = 'Gemini CLI';
     command = 'gemini';
-    /**
-     * Check if Gemini session is running for a worktree
-     *
-     * @param worktreeId - Worktree ID
-     * @returns True if session is running
-     */
-    async isRunning(worktreeId, instanceId) {
-        const sessionName = this.getSessionName(worktreeId, instanceId);
-        return await (0, tmux_1.hasSession)(sessionName);
-    }
     /**
      * Start a new Gemini session for a worktree
      * Launches `gemini` in interactive REPL mode within tmux
@@ -65,27 +49,14 @@ class GeminiTool extends base_1.BaseCLITool {
      */
     async launchSession(worktreeId, worktreePath, instanceId) {
         // Check if Gemini is installed
-        const geminiAvailable = await this.isInstalled();
-        if (!geminiAvailable) {
-            throw (0, install_hints_1.missingToolError)(this);
-        }
-        const sessionName = this.getSessionName(worktreeId, instanceId);
-        // Check if session already exists
-        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('gemini-session-sessionname');
-                return;
-            }
-            logger.warn('gemini-session-relaunch', { sessionName });
-        }
+        await this.requireInstalled();
+        const { sessionName, exists, live } = await this.resolveLaunchPane(worktreeId, worktreePath, instanceId, {
+            logger,
+            liveAction: 'gemini-session-exists',
+            relaunchAction: 'gemini-session-relaunch',
+        });
+        if (live)
+            return;
         // 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
         // path only — the reuse branch above has already returned — and before the
@@ -102,14 +73,7 @@ class GeminiTool 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);
             }
             // Start Gemini CLI in interactive mode (no flags = interactive REPL).
             //
@@ -135,10 +99,10 @@ class GeminiTool extends base_1.BaseCLITool {
             // Poll until Gemini interactive prompt is ready
             // Handles trust dialog automatically if encountered
             await this.waitForReady(sessionName);
-            logger.info('started-gemini-session:sessionname');
+            logger.info('started-gemini-session');
         }
         catch (error) {
-            const errorMessage = getErrorMessage(error);
+            const errorMessage = (0, errors_1.getErrorMessage)(error);
             throw new Error(`Failed to start Gemini session: ${errorMessage}`);
         }
     }
@@ -164,7 +128,7 @@ class GeminiTool extends base_1.BaseCLITool {
                 if (!trustDialogHandled && output.includes('Do you trust this folder?')) {
                     await (0, tmux_1.sendSpecialKey)(sessionName, 'Enter');
                     trustDialogHandled = true;
-                    logger.info('auto-trusted-folder-for');
+                    logger.info('auto-trusted-folder-for-gemini');
                     // Continue polling for prompt after trust dialog
                 }
             }
@@ -195,7 +159,7 @@ class GeminiTool extends base_1.BaseCLITool {
             }
             await new Promise((resolve) => setTimeout(resolve, pollInterval));
         }
-        logger.info('gemini-prompt-not');
+        logger.info('gemini-prompt-not-detected');
     }
     /**
      * Send a message to Gemini interactive session
@@ -205,17 +169,12 @@ class GeminiTool extends base_1.BaseCLITool {
      */
     async sendMessage(worktreeId, message, instanceId) {
         const sessionName = this.getSessionName(worktreeId, instanceId);
-        // Check if session exists
-        const exists = await (0, tmux_1.hasSession)(sessionName);
-        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);
+        await this.requireSession('Gemini', worktreeId, instanceId, { relaunch: true });
         try {
             // Verify Gemini is at prompt state before sending
             await this.waitForPrompt(sessionName);
@@ -229,10 +188,10 @@ class GeminiTool extends base_1.BaseCLITool {
             });
             // Issue #405: Invalidate cache after sending message
             (0, tmux_capture_cache_1.invalidateCache)(sessionName);
-            logger.info('sent-message-to-gemini-session:sessionna');
+            logger.info('sent-message-to-gemini-session');
         }
         catch (error) {
-            const errorMessage = getErrorMessage(error);
+            const errorMessage = (0, errors_1.getErrorMessage)(error);
             throw new Error(`Failed to send message to Gemini: ${errorMessage}`);
         }
     }
@@ -242,27 +201,18 @@ class GeminiTool 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-gemini-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 /quit to exit Gemini gracefully
                 await (0, tmux_1.sendKeys)(sessionName, '/quit', true);
                 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-gemini-session:sessionname');
-            }
-        }
-        catch (error) {
-            logger.error('session:stop-failed', { error: getErrorMessage(error) });
-            throw error;
-        }
+            },
+        });
     }
 }
 exports.GeminiTool = GeminiTool;

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveOpencodePaneWidthChecked = resolveOpencodePaneWidthChecked;
+const tmux_pane_config_1 = require("../../config/tmux-pane-config");
+const logger_1 = require("../../lib/logger");
+const logger = (0, logger_1.createLogger)('cli-tools/opencode-pane-width');
+/**
+ * {@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(options) {
+    const requested = process.env[tmux_pane_config_1.OPENCODE_PANE_WIDTH_ENV];
+    const width = (0, tmux_pane_config_1.resolveOpencodePaneWidth)();
+    // "Dropped" means the resolver fell back to the default. Compare the number
+    // the operator wrote, not its text: `0120` is applied as 120 (#3338).
+    const trimmed = requested?.trim();
+    const dropped = trimmed !== undefined && (!/^\d+$/.test(trimmed) || Number.parseInt(trimmed, 10) !== width);
+    if (requested !== undefined && dropped) {
+        logger.warn('opencode-pane-width-rejected', {
+            requested,
+            applied: width,
+        });
+    }
+    else if (options.warnSidebar && width >= tmux_pane_config_1.OPENCODE_SIDEBAR_MIN_WIDTH) {
+        // v1 only: the width at which opencode-v2 starts painting a sidebar has not
+        // been measured, so v2 passes `warnSidebar: false` (Issue #3296).
+        logger.warn('opencode-pane-width-sidebar-visible', {
+            width,
+            sidebarMinWidth: tmux_pane_config_1.OPENCODE_SIDEBAR_MIN_WIDTH,
+        });
+    }
+    return width;
+}

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

@@ -45,6 +45,7 @@ const cli_patterns_1 = require("../detection/cli-patterns");
 const submit_verified_sender_1 = require("./submit-verified-sender");
 const tmux_capture_cache_1 = require("../tmux/tmux-capture-cache");
 const tmux_pane_config_1 = require("../../config/tmux-pane-config");
+const opencode_pane_width_1 = require("./opencode-pane-width");
 const logger_1 = require("../../lib/logger");
 const errors_1 = require("../../lib/errors");
 const agent_session_lifecycle_1 = require("../../lib/session/agent-session-lifecycle");
@@ -200,7 +201,9 @@ class OpenCodeV2Tool extends base_1.BaseCLITool {
         }
         const sessionName = this.getSessionName(worktreeId, instanceId);
         const target = (0, runtime_1.opencodeV2Target)(worktreeId, instanceId);
-        const geometry = { windowWidth: (0, tmux_pane_config_1.resolveOpencodePaneWidth)(), windowHeight: tmux_pane_config_1.OPENCODE_PANE_HEIGHT };
+        // Issue #3296: the "sidebar visible" warn is off for v2 (see opencode-pane-width.ts).
+        const paneWidth = (0, opencode_pane_width_1.resolveOpencodePaneWidthChecked)({ warnSidebar: false });
+        const geometry = { windowWidth: paneWidth, windowHeight: tmux_pane_config_1.OPENCODE_PANE_HEIGHT };
         const exists = await (0, tmux_1.hasSession)(sessionName);
         if (exists) {
             await this.reconcileExistingSession(sessionName, worktreePath, geometry);
@@ -216,8 +219,7 @@ class OpenCodeV2Tool extends base_1.BaseCLITool {
         (0, agent_session_lifecycle_1.beginAgentSession)(target);
         try {
             if (!exists) {
-                await (0, tmux_1.createSession)({ sessionName, workingDirectory: worktreePath });
-                await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.TUI_SESSION_CREATE_WAIT_MS));
+                await this.createLaunchPane(sessionName, worktreePath);
             }
             try {
                 await execFileAsync('tmux', [
@@ -298,10 +300,7 @@ class OpenCodeV2Tool extends base_1.BaseCLITool {
     }
     async sendMessage(worktreeId, message, instanceId) {
         const sessionName = this.getSessionName(worktreeId, instanceId);
-        if (!(await (0, tmux_1.hasSession)(sessionName))) {
-            throw new Error(`OpenCode V2 session ${sessionName} does not exist. Start the session first.`);
-        }
-        await this.relaunchIfToolExited(worktreeId, instanceId);
+        await this.requireSession('OpenCode V2', worktreeId, instanceId, { relaunch: true });
         try {
             await this.waitForComposer(sessionName);
             await (0, submit_verified_sender_1.sendMessageWithSubmitVerification)({
@@ -356,6 +355,9 @@ class OpenCodeV2Tool extends base_1.BaseCLITool {
             }
             (0, tmux_capture_cache_1.invalidateCache)(sessionName);
             this.resumeAttemptedAt.delete(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-v2-session');
         }
         catch (error) {