commandmate 0.44.1 → 0.44.3

package/dist/server/src/lib/auto-yes-state.js

@@ -35,6 +35,7 @@ const auto_yes_config_1 = require("../config/auto-yes-config");
 const path_validator_1 = require("./security/path-validator");
 const types_1 = require("./cli-tools/types");
 const logger_1 = require("../lib/logger");
+const global_state_1 = require("./global-state");
 const logger = (0, logger_1.createLogger)('auto-yes-state');
 // =============================================================================
 // Composite Key Helpers (Issue #525: per-agent auto-yes)
@@ -117,8 +118,7 @@ function extractInstanceId(compositeKey) {
     return parts[2] ?? parts[1] ?? null;
 }
 /** In-memory storage for auto-yes states (globalThis for hot reload persistence) */
-const autoYesStates = globalThis.__autoYesStates ??
-    (globalThis.__autoYesStates = new Map());
+const autoYesStates = (0, global_state_1.getOrInitGlobal)('__autoYesStates', () => new Map());
 // =============================================================================
 // Utility Functions
 // =============================================================================

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

@@ -25,16 +25,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/antigravity');
-/**
- * Extract error message from unknown error type (DRY).
- * Same pattern as codex.ts / claude-session.ts getErrorMessage().
- */
-function getErrorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}
 /**
  * Single-quote a value for safe embedding in a shell command typed into a
  * tmux pane (Issue #989). Unlike other CLI tools, agy's `--model` is a
@@ -150,7 +143,7 @@ function readInputBoxStatusRow(contentLines) {
  * @returns True when the input box is live and agy is idle
  */
 function isAntigravityReady(output) {
-    const frame = (0, frame_1.normalizeFrame)(output);
+    const frame = (0, frame_1.normalizeFrame)(output, 'antigravity');
     if (cli_patterns_1.ANTIGRAVITY_SELECTION_LIST_PATTERN.test(frame.lastLines))
         return false;
     if (ANTIGRAVITY_TRUST_DIALOG_PATTERN.test(frame.lastLines))
@@ -170,16 +163,6 @@ class AntigravityTool extends base_1.BaseCLITool {
     id = 'antigravity';
     name = 'Antigravity CLI';
     command = 'agy';
-    /**
-     * Check if an Antigravity 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 Antigravity session for a worktree.
      *
@@ -193,27 +176,14 @@ class AntigravityTool extends base_1.BaseCLITool {
      */
     async launchSession(worktreeId, worktreePath, instanceId, model) {
         // Check if agy is installed
-        const available = await this.isInstalled();
-        if (!available) {
-            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('antigravity-session-exists');
-                return;
-            }
-            logger.warn('antigravity-session-relaunch', { sessionName });
-        }
+        await this.requireInstalled();
+        const { sessionName, exists, live } = await this.resolveLaunchPane(worktreeId, worktreePath, instanceId, {
+            logger,
+            liveAction: 'antigravity-session-exists',
+            relaunchAction: 'antigravity-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. Creation path
         // only — the reuse branch above has already returned — and before the pane
@@ -224,21 +194,6 @@ class AntigravityTool extends base_1.BaseCLITool {
         // the new one's.
         (0, agent_session_lifecycle_1.beginAgentSession)({ worktreeId, cliToolId: sources_1.ANTIGRAVITY_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 with large history buffer for agy output
-                // (agy is inline-rendered and retains scrollback, like Codex)
-                // 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 agy in interactive mode, optionally pinned to a model.
             //
             // Issue #1762: the launch merges CommandMate's named hook into
@@ -249,12 +204,28 @@ class AntigravityTool extends base_1.BaseCLITool {
             // one file serves every worktree on the machine. `--model` is appended
             // after the rendered line, so the env assignments stay in front of the
             // command. `CM_AGENT_HOOKS_INJECT=0` returns bare `agy`, unchanged.
+            // Under UAT isolation (Issue #3360) a shared file this build did not
+            // produce makes the plan throw.
             const base = (0, agent_session_lifecycle_1.buildAgentLaunchCommandLine)({
                 target: { worktreeId, cliToolId: sources_1.ANTIGRAVITY_CLI_TOOL_ID, instanceId },
                 executablePath: this.command,
                 worktreePath,
             });
             const launchCommand = model ? `${base} --model ${shellSingleQuote(model)}` : base;
+            // Issue #3360: the plan above is built BEFORE the tmux session, because
+            // under UAT isolation it throws instead of launching — and a refused
+            // launch must not leave an empty pane that `isRunning()` reports as a
+            // started agy (the next send would then be refused a model change).
+            // 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 with large history buffer for agy output
+                // (agy is inline-rendered and retains scrollback, like Codex)
+                // Scrollback depth comes from the shared TMUX_HISTORY_LIMIT default
+                // (Issue #1624) — do not re-hardcode it here.
+                await this.createLaunchPane(sessionName, worktreePath);
+            }
             await (0, tmux_1.sendKeys)(sessionName, (0, launch_screen_1.withLaunchScreenCleared)(launchCommand), true);
             // Wait for agy to initialize
             await new Promise((resolve) => setTimeout(resolve, ANTIGRAVITY_INIT_WAIT_MS));
@@ -263,7 +234,7 @@ class AntigravityTool extends base_1.BaseCLITool {
             logger.info('started-antigravity-session');
         }
         catch (error) {
-            const errorMessage = getErrorMessage(error);
+            const errorMessage = (0, errors_1.getErrorMessage)(error);
             throw new Error(`Failed to start Antigravity session: ${errorMessage}`);
         }
     }
@@ -336,17 +307,12 @@ class AntigravityTool 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(`Antigravity 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('Antigravity', worktreeId, instanceId, { relaunch: true });
         try {
             // Verify agy is at a ready prompt before sending
             await this.waitForPrompt(sessionName);
@@ -363,7 +329,7 @@ class AntigravityTool extends base_1.BaseCLITool {
             logger.info('sent-message-to-antigravity-session');
         }
         catch (error) {
-            const errorMessage = getErrorMessage(error);
+            const errorMessage = (0, errors_1.getErrorMessage)(error);
             throw new Error(`Failed to send message to Antigravity: ${errorMessage}`);
         }
     }
@@ -373,27 +339,20 @@ class AntigravityTool 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-antigravity-session',
+            requestExit: async (sessionName) => {
                 // Send Ctrl+D to exit agy gracefully
                 await (0, tmux_1.sendSpecialKey)(sessionName, 'C-d');
                 // Wait a moment for agy to exit
                 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);
-            // Invalidate cache so a later session reusing the name starts clean
-            (0, tmux_capture_cache_1.invalidateCache)(sessionName);
-            if (killed) {
-                logger.info('stopped-antigravity-session');
-            }
-        }
-        catch (error) {
-            logger.error('session:stop-failed', { error: getErrorMessage(error) });
-            throw error;
-        }
+            },
+            afterKill: (sessionName) => {
+                // Invalidate cache so a later session reusing the name starts clean
+                (0, tmux_capture_cache_1.invalidateCache)(sessionName);
+            },
+        });
     }
 }
 exports.AntigravityTool = AntigravityTool;

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

@@ -21,10 +21,12 @@ const graceful_exit_1 = require("./graceful-exit");
 const liveness_spec_1 = require("./liveness-spec");
 const session_liveness_1 = require("./session-liveness");
 const start_availability_1 = require("./start-availability");
+const install_hints_1 = require("./install-hints");
 const ansi_1 = require("../detection/ansi");
 const env_1 = require("../env");
 const launch_command_1 = require("../hooks/sources/launch-command");
 const logger_1 = require("../logger");
+const errors_1 = require("../errors");
 const terminal_keys_1 = require("../../types/terminal-keys");
 const cli_tool_timing_config_1 = require("../../config/cli-tool-timing-config");
 const tmux_pane_config_1 = require("../../config/tmux-pane-config");
@@ -177,6 +179,11 @@ class BaseCLITool {
     getSessionName(worktreeId, instanceId) {
         return (0, session_name_1.resolveSessionName)(this.id, worktreeId, instanceId);
     }
+    // Abstract methods that must be implemented by subclasses
+    async isRunning(worktreeId, instanceId) {
+        const sessionName = this.getSessionName(worktreeId, instanceId);
+        return await (0, tmux_1.hasSession)(sessionName);
+    }
     /**
      * Start this tool's session, reporting a failure exactly once (Issue #2009).
      *
@@ -595,6 +602,150 @@ class BaseCLITool {
         logger.info('session:relaunch-before-send', { cliToolId: this.id, sessionName });
         await this.startSession(worktreeId, worktreePath, instanceId);
     }
+    /**
+     * The pre-send guard every driver's `sendMessage` opened with: the session
+     * must exist, else throw `<label> session <name> does not exist. Start the
+     * session first.`; with `relaunch`, a pane whose tool has exited is then
+     * relaunched ({@link relaunchIfToolExited}) before the caller goes on.
+     *
+     * @param label - Tool name as it appears in the error text (e.g. `Command Code`)
+     * @param worktreeId - Worktree ID
+     * @param instanceId - Agent instance ID (defaults to the primary instance)
+     * @param options.relaunch - Also relaunch a tool that exited inside a live pane
+     */
+    async requireSession(label, worktreeId, instanceId, options) {
+        const sessionName = this.getSessionName(worktreeId, instanceId);
+        const exists = await (0, tmux_1.hasSession)(sessionName);
+        if (!exists) {
+            throw new Error(`${label} session ${sessionName} does not exist. Start the session first.`);
+        }
+        if (options.relaunch) {
+            await this.relaunchIfToolExited(worktreeId, instanceId);
+        }
+    }
+    /**
+     * The install check a driver's `launchSession` opens with: a tool that is not
+     * installed stops the launch with {@link missingToolError}.
+     *
+     * copilot, opencode and OpenCode V2 do not call this. Each resolves the
+     * executable its launch line then names, so there the check and the line come
+     * from one measurement.
+     *
+     * @throws SessionStartUnavailableError when {@link isInstalled} answers false
+     */
+    async requireInstalled() {
+        const available = await this.isInstalled();
+        if (!available) {
+            throw (0, install_hints_1.missingToolError)(this);
+        }
+    }
+    /**
+     * The reuse decision a driver's `launchSession` makes before it types
+     * anything: name the session and, when its pane already exists, reconcile it
+     * ({@link reconcileExistingSession}) and ask whether the tool is still the
+     * thing drawing it ({@link isToolLive}, confirmed).
+     *
+     * Both log lines go through the caller's logger under the caller's action
+     * names, so each driver's log reads as it did when this sequence was written
+     * out in every one of them.
+     *
+     * opencode and OpenCode V2 keep their own copy: they hand the reconcile their
+     * pane geometry, resume their event stream on the live branch and release it
+     * on the relaunch branch.
+     *
+     * @param worktreeId - Worktree ID
+     * @param worktreePath - Worktree path
+     * @param instanceId - Agent instance ID (defaults to the primary instance)
+     * @param log.logger - The driver's logger
+     * @param log.liveAction - Logged when a live tool already holds the pane
+     * @param log.relaunchAction - Logged when the pane exists and its tool has exited
+     * @returns The session name; `exists` when its pane was already there; `live`
+     *   when the tool is still in it, so the caller has nothing to launch
+     * @throws {ForeignSessionError} From {@link reconcileExistingSession}
+     */
+    async resolveLaunchPane(worktreeId, worktreePath, instanceId, log) {
+        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 })) {
+                log.logger.info(log.liveAction);
+                return { sessionName, exists, live: true };
+            }
+            log.logger.warn(log.relaunchAction, { sessionName });
+        }
+        return { sessionName, exists, live: false };
+    }
+    /**
+     * Create the tmux session a launch types into, then wait
+     * {@link TUI_SESSION_CREATE_WAIT_MS} for it. Creation path only: on the #2070
+     * relaunch path the pane already exists and the caller does not come here.
+     *
+     * @param sessionName - tmux session name
+     * @param worktreePath - Worktree path, the session's working directory
+     */
+    async createLaunchPane(sessionName, 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));
+    }
+    /**
+     * The stop sequence a driver's `killSession` runs: name the session, ask the
+     * tool to quit when its pane exists, kill the tmux session, run the driver's
+     * cleanup and log.
+     *
+     * The keys and waits that ask the tool to quit stay in each driver, as
+     * `requestExit`: they are measured per tool, and {@link gracefulExitSequence}
+     * describes them without sending them. Both log lines go through the caller's
+     * logger, the stop line under the caller's action name, so each driver's log
+     * reads as it did when this sequence was written out in every one of them.
+     *
+     * `afterKill` runs after the tmux kill and before the stop line, inside the
+     * same `try`, whether or not tmux had a session to kill.
+     *
+     * claude, opencode and OpenCode V2 keep their own `killSession`: claude hands
+     * the stop to `stopClaudeSession`, and the other two check the exit's
+     * postcondition and release what the instance held.
+     *
+     * @param worktreeId - Worktree ID
+     * @param instanceId - Agent instance ID (defaults to the primary instance)
+     * @param stop.logger - The driver's logger
+     * @param stop.stoppedAction - Logged when tmux reports it killed the session
+     * @param stop.requestExit - The driver's exit keys and the waits between them
+     * @param stop.afterKill - The driver's cleanup once the tmux kill has run
+     * @throws Whatever the sequence threw, unchanged, after logging `session:stop-failed`
+     */
+    async requestExitAndKill(worktreeId, instanceId, stop) {
+        const sessionName = this.getSessionName(worktreeId, instanceId);
+        try {
+            const exists = await (0, tmux_1.hasSession)(sessionName);
+            if (exists) {
+                await stop.requestExit(sessionName);
+            }
+            // Kill the tmux session
+            const killed = await (0, tmux_1.killSession)(sessionName);
+            stop.afterKill?.(sessionName);
+            if (killed) {
+                stop.logger.info(stop.stoppedAction);
+            }
+        }
+        catch (error) {
+            stop.logger.error('session:stop-failed', { error: (0, errors_1.getErrorMessage)(error) });
+            throw error;
+        }
+    }
     /**
      * Declare the keys this tool's terminal UI may send (Issue #2046).
      *

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

@@ -19,16 +19,9 @@ const sources_1 = require("../../lib/hooks/sources");
 const hooks_config_1 = require("../../lib/hooks/sources/codex/hooks-config");
 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 launch_screen_1 = require("../../lib/session/launch-screen");
+const errors_1 = require("../../lib/errors");
 const logger = (0, logger_1.createLogger)('cli-tools/codex');
-/**
- * Extract error message from unknown error type (DRY)
- * Same pattern as claude-session.ts getErrorMessage()
- */
-function getErrorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}
 /** Wait for Codex CLI to initialize after launch */
 const CODEX_INIT_WAIT_MS = 3000;
 /** Interval for polling trust dialog / prompt detection */
@@ -179,16 +172,6 @@ class CodexTool extends base_1.BaseCLITool {
     id = 'codex';
     name = 'Codex CLI';
     command = 'codex';
-    /**
-     * Check if Codex 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 Codex session for a worktree
      *
@@ -197,29 +180,22 @@ class CodexTool extends base_1.BaseCLITool {
      */
     async launchSession(worktreeId, worktreePath, instanceId) {
         // Check if Codex is installed
-        const codexAvailable = await this.isInstalled();
-        if (!codexAvailable) {
-            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, and that is
-            // the second half of the reported bug. codex's own "1. Update now"
-            // replaces codex with `npm install` and exits; `Ctrl+C` twice quits it; a
-            // crash does the same. The tmux session survives all three, so `exists`
-            // stays true and the launch was skipped for a pane that had nothing but a
-            // shell prompt in it — leaving `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('codex-session-sessionname');
-                return;
-            }
-            logger.warn('codex-session-relaunch', { sessionName });
-        }
+        await this.requireInstalled();
+        // Issue #2070: this branch used to return unconditionally, and that is
+        // the second half of the reported bug. codex's own "1. Update now"
+        // replaces codex with `npm install` and exits; `Ctrl+C` twice quits it; a
+        // crash does the same. The tmux session survives all three, so `exists`
+        // stays true and the launch was skipped for a pane that had nothing but a
+        // shell prompt in it — leaving `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.
+        const { sessionName, exists, live } = await this.resolveLaunchPane(worktreeId, worktreePath, instanceId, {
+            logger,
+            liveAction: 'codex-session-exists',
+            relaunchAction: 'codex-session-relaunch',
+        });
+        if (live)
+            return;
         // Issue #1760: everything the previous codex 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. Without this
@@ -234,17 +210,6 @@ class CodexTool extends base_1.BaseCLITool {
         // NOT fence: there the process is the same one.)
         (0, agent_session_lifecycle_1.beginAgentSession)({ worktreeId, cliToolId: sources_1.CODEX_CLI_TOOL_ID, instanceId });
         try {
-            if (!exists) {
-                // Create tmux session. Codex is inline-rendered, so its transcript lives in
-                // the pane 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 #1760: hand this session its correlation keys, writing codex's
             // hooks config first if it is not already there. codex has no
             // `--settings`, so the keys ride in environment assignments on the launch
@@ -253,12 +218,21 @@ class CodexTool extends base_1.BaseCLITool {
             //
             // Falls back to the bare command on any failure and when
             // `CM_AGENT_HOOKS_INJECT=0`; a session that starts without hooks is the
-            // pre-#1760 status quo, and a session that fails to start is not.
+            // pre-#1760 status quo, and a session that fails to start is not. The one
+            // exception is UAT isolation (Issue #3360), 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 codex.
             const launchCommand = (0, agent_session_lifecycle_1.buildAgentLaunchCommandLine)({
                 target: { worktreeId, cliToolId: sources_1.CODEX_CLI_TOOL_ID, instanceId },
                 executablePath: this.command,
                 worktreePath,
             });
+            if (!exists) {
+                // Create tmux session. Codex is inline-rendered, so its transcript lives in
+                // the pane scrollback — depth comes from the shared TMUX_HISTORY_LIMIT
+                // default (Issue #1624), do not re-hardcode it here.
+                await this.createLaunchPane(sessionName, worktreePath);
+            }
             // Issue #2068: re-send the SAME launch line into the SAME pane, for the
             // one case where a launch legitimately has to happen twice — codex's own
             // `1. Update now` replaces codex with `npm install -g @openai/codex` and
@@ -286,10 +260,10 @@ class CodexTool extends base_1.BaseCLITool {
                 relaunch: relaunchIntoSamePane,
                 trustHooks: (0, hooks_config_1.shouldTrustCodexHooks)(worktreePath),
             });
-            logger.info('started-codex-session:sessionname');
+            logger.info('started-codex-session');
         }
         catch (error) {
-            const errorMessage = getErrorMessage(error);
+            const errorMessage = (0, errors_1.getErrorMessage)(error);
             throw new Error(`Failed to start Codex session: ${errorMessage}`);
         }
     }
@@ -556,7 +530,7 @@ class CodexTool extends base_1.BaseCLITool {
                         // Issue #890: number-key selection confirms instantly; no trailing Enter.
                         await (0, tmux_1.sendKeys)(sessionName, '1', false);
                         trustDialogHandled = true;
-                        logger.info('auto-trusted-folder-for');
+                        logger.info('auto-trusted-folder-for-codex');
                         await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.CODEX_DIALOG_SETTLE_MS));
                         continue;
                     }
@@ -707,7 +681,7 @@ class CodexTool extends base_1.BaseCLITool {
             }
             await new Promise((resolve) => setTimeout(resolve, pollInterval));
         }
-        logger.info('codex-prompt-not');
+        logger.info('codex-prompt-not-detected');
         throw new Error('Codex prompt not ready: timed out waiting for the input prompt before sending');
     }
     /**
@@ -718,18 +692,13 @@ class CodexTool 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(`Codex session ${sessionName} does not exist. Start the session first.`);
-        }
         // Issue #2070: the pane exists, but does the AGENT? codex's "1. Update now"
         // replaces it with `npm install` and exits, `Ctrl+C` twice quits it, a crash
         // does the same — and the send that follows 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('Codex', worktreeId, instanceId, { relaunch: true });
         try {
             // Verify Codex is at prompt state before sending
             await this.waitForPrompt(sessionName);
@@ -742,13 +711,17 @@ class CodexTool extends base_1.BaseCLITool {
                 // Issue #1933: the tool describes its own composer; the sender no
                 // longer keys three module-level tables on the id.
                 composer: this.describeComposer(),
+                // Issue #3366: codex draws fast keystrokes only when the burst ends and
+                // turns an Enter that arrives before that into a newline, so Enter
+                // waits until the composer shows the body.
+                awaitTypedBody: true,
             });
             // Issue #405: Invalidate cache after sending message
             (0, tmux_capture_cache_1.invalidateCache)(sessionName);
-            logger.info('sent-message-to-codex-session:sessionnam');
+            logger.info('sent-message-to-codex-session');
         }
         catch (error) {
-            const errorMessage = getErrorMessage(error);
+            const errorMessage = (0, errors_1.getErrorMessage)(error);
             throw new Error(`Failed to send message to Codex: ${errorMessage}`);
         }
     }
@@ -758,26 +731,17 @@ class CodexTool extends base_1.BaseCLITool {
      * @param worktreeId - Worktree ID
      */
     async killSession(worktreeId, instanceId) {
-        const sessionName = this.getSessionName(worktreeId, instanceId);
-        try {
+        await this.requestExitAndKill(worktreeId, instanceId, {
+            logger,
+            stoppedAction: 'stopped-codex-session',
             // Send Ctrl+D to exit Codex gracefully
-            const exists = await (0, tmux_1.hasSession)(sessionName);
-            if (exists) {
+            requestExit: async (sessionName) => {
                 // Send Ctrl+D (ASCII 4)
                 await (0, tmux_1.sendSpecialKey)(sessionName, 'C-d');
                 // Wait a moment for Codex to exit
                 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-codex-session:sessionname');
-            }
-        }
-        catch (error) {
-            logger.error('session:stop-failed', { error: getErrorMessage(error) });
-            throw error;
-        }
+            },
+        });
     }
 }
 exports.CodexTool = CodexTool;