commandmate 0.26.1 → 0.27.0

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

@@ -1,20 +1,29 @@
 "use strict";
 /**
  * Copilot CLI tool implementation
- * Issue #545: Provides integration with GitHub Copilot CLI via `gh copilot`
+ * Issue #545: Provides integration with GitHub Copilot CLI
  *
- * Uses `gh` as the base command with `copilot` subcommand.
- * isInstalled() is overridden to use execFile (not exec) for security [SEC4-001],
- * performing a 2-stage check: gh availability + copilot extension presence.
+ * Copilot CLI is a standalone executable (`brew install copilot-cli`,
+ * `npm i -g @github/copilot`), NOT a gh extension — the `gh-copilot` extension
+ * this module was written against is a different, retired product, and `gh`'s
+ * own `copilot` command is a preview wrapper that *downloads* the standalone
+ * binary when `PATH` has none. So the base command is `copilot` and `gh copilot`
+ * is only the fallback for a machine whose copy gh downloaded for itself
+ * (Issue #1907).
+ *
+ * isInstalled() is overridden to require positive evidence — an executable that
+ * answers `--version` — rather than the absence of an error from a help screen.
+ * See `./copilot-executable`, which also keeps execFile (not exec) for security
+ * [SEC4-001].
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CopilotTool = void 0;
-const child_process_1 = require("child_process");
+exports.CopilotTool = exports.COPILOT_EXIT_COMMAND = void 0;
 const base_1 = require("./base");
 const tmux_1 = require("../tmux/tmux");
 const submit_verified_sender_1 = require("./submit-verified-sender");
 const tmux_capture_cache_1 = require("../tmux/tmux-capture-cache");
 const cli_patterns_1 = require("../detection/cli-patterns");
+const copilot_executable_1 = require("./copilot-executable");
 const copilot_constants_1 = require("../../config/copilot-constants");
 const cli_tool_timing_config_1 = require("../../config/cli-tool-timing-config");
 const agent_session_lifecycle_1 = require("../../lib/session/agent-session-lifecycle");
@@ -22,9 +31,8 @@ const hook_settings_1 = require("../../lib/hooks/sources/copilot/hook-settings")
 const tool_id_1 = require("../../lib/hooks/sources/copilot/tool-id");
 const errors_1 = require("../../lib/errors");
 const logger_1 = require("../../lib/logger");
+const session_start_error_1 = require("../session/session-start-error");
 const logger = (0, logger_1.createLogger)('cli-tools/copilot');
-/** Wait for Copilot CLI to initialize after launch */
-const COPILOT_INIT_WAIT_MS = 4000;
 /** Interval for polling prompt detection */
 const COPILOT_POLL_INTERVAL_MS = 1000;
 /** Max attempts for initialization polling (30 * 1000ms = 30s total window) */
@@ -32,57 +40,109 @@ const COPILOT_INIT_MAX_ATTEMPTS = 30;
 /** Timeout for waiting for prompt before sending a message */
 const COPILOT_PROMPT_WAIT_TIMEOUT_MS = 15000;
 /**
- * Copilot CLI slash commands that trigger a selection list UI.
- * These commands open an interactive picker after execution.
- * When sending these, we must wait for the selection list to appear
- * before allowing further input, to prevent text leaking into the search field.
+ * Copilot CLI slash commands that open a picker.
+ *
+ * Sending one is not like sending a message: the picker takes the composer
+ * away, so anything typed afterwards lands in the picker's own search field and
+ * any stray Enter/`n`/`x` is a keystroke the picker acts on. (Measured while
+ * capturing the frames for Issue #1895: text sent into an open `/session`
+ * picker created a session. `/session` is also the one picker `esc` does not
+ * close.) That is why this branch sends the command, waits for positive
+ * evidence that the picker is up, and then stops.
+ *
+ * All eleven commands #1913 measured on 1.0.80 are listed. The set was
+ * `model`/`agent`/`theme`, and the note left in its place said to widen it "once
+ * the pattern actually matches 1.0.80 frames" -- which is what Issue #1895 did:
+ * {@link isCopilotSelectionFrame} matches all eleven of the live frames in
+ * `tests/unit/lib/detection/fixtures/copilot-picker-1895/`, so the wait now
+ * returns on evidence in ~300ms instead of expiring at 5s. Widening was cheap
+ * only because of that; each entry still buys a wait, so this stays the eleven
+ * that were opened and captured rather than a guess about the rest of the
+ * catalogue.
+ *
+ * Issue #1906 is what made any of it live. Until then `send-user-message.ts` and
+ * the terminal route both bypassed this method with a raw `sendKeys` + delayed
+ * Enter, so this branch — and `waitForPrompt`'s folder-trust answer (#1886) —
+ * were unreachable in production. Both bypasses are gone; every path that types
+ * a message at copilot comes through here.
+ */
+const SELECTION_LIST_COMMANDS = new Set([
+    'model',
+    'agent',
+    'theme',
+    'permissions',
+    'skills',
+    'mcp',
+    'settings',
+    'statusline',
+    'subagents',
+    'resume',
+    'session',
+]);
+/**
+ * The composer row, matched one line at a time (Issue #1907).
+ *
+ * `COPILOT_PROMPT_PATTERN` is written for whole frames, where its `\s` can match
+ * the newline that follows a bare `❯`; against a single line there is nothing
+ * after the glyph for it to match. Anchored at column 0, which is where copilot
+ * draws the composer and where it draws nothing else — while a dialog is up the
+ * row is removed from the frame entirely (Issue #1886).
  */
-const SELECTION_LIST_COMMANDS = new Set(['model', 'agent', 'theme']);
+const COPILOT_COMPOSER_ROW_PATTERN = /^[>❯](?:\s|$)/;
+/**
+ * The TUI command that ends a Copilot session (Issue #1905).
+ *
+ * Copilot 1.0.80 accepts several spellings — `/exit`, `Ctrl+C` twice and
+ * `Ctrl+D` all end the process, and a bare `exit` submitted from the composer
+ * does too (measured; the Issue's premise that it merely becomes a chat message
+ * is wrong for this version). The slash form is the documented one and the only
+ * one that cannot be mistaken for a prompt, so it is what is sent.
+ */
+exports.COPILOT_EXIT_COMMAND = '/exit';
 /**
  * Copilot CLI tool implementation
  * Manages GitHub Copilot interactive sessions using tmux
  *
- * command = 'gh' because Copilot is a gh extension.
- * isInstalled() overrides BaseCLITool to use execFile (security) and
- * performs 2-stage verification: gh CLI + copilot extension. [DR1-004][SEC4-001]
+ * command = 'copilot': the standalone executable, which is what both supported
+ * installers put on PATH. It used to be `gh`, from the days when copilot was the
+ * `gh-copilot` extension (Issue #1907).
+ *
+ * isInstalled() overrides BaseCLITool because `which copilot` is not enough
+ * evidence on its own and because gh's downloaded copy is deliberately off PATH.
+ * [DR1-004][SEC4-001]
  */
 class CopilotTool extends base_1.BaseCLITool {
     id = 'copilot';
     name = 'Copilot';
-    command = 'gh';
+    command = 'copilot';
     /**
      * Check if GitHub Copilot CLI is available.
-     * Two-stage check using execFile (not exec) for security [SEC4-001]:
-     * 1. Verify `gh` is installed (gh --version)
-     * 2. Verify copilot extension is available (gh copilot --help)
      *
-     * @returns True if both gh and copilot extension are available
+     * Issue #1907: this used to be `gh --version` followed by `gh copilot --help`,
+     * both of which exit 0 on a machine with no copilot at all — `copilot` is a
+     * preview command built into gh, and its help says it will *download* the CLI
+     * if none is installed. The badge was wrong and, worse, `startSession` then
+     * typed `gh copilot` into the pane and the download ran there.
+     *
+     * Delegates to {@link resolveCopilotExecutable}, which answers with positive
+     * evidence only: an executable file that exits 0 on `--version` and prints a
+     * version string.
+     *
+     * @returns True when a copilot executable was found and answered
      */
     async isInstalled() {
-        try {
-            // Stage 1: Check gh CLI availability
-            await new Promise((resolve, reject) => {
-                (0, child_process_1.execFile)('gh', ['--version'], { timeout: 5000 }, (error) => {
-                    if (error)
-                        reject(error);
-                    else
-                        resolve();
-                });
-            });
-            // Stage 2: Check copilot extension availability
-            await new Promise((resolve, reject) => {
-                (0, child_process_1.execFile)('gh', ['copilot', '--help'], { timeout: 5000 }, (error) => {
-                    if (error)
-                        reject(error);
-                    else
-                        resolve();
-                });
-            });
-            return true;
-        }
-        catch {
-            return false;
-        }
+        return (await (0, copilot_executable_1.resolveCopilotExecutable)()) !== null;
+    }
+    /**
+     * The command line that starts the resolved copilot in a pane.
+     *
+     * `PATH` first (Issue #1907). `gh copilot` is reached only for a copy gh
+     * downloaded for itself: it is not on PATH by design, and gh prefers PATH, so
+     * gh runs exactly the file that was probed. Because the probe already proved
+     * that file exists, this branch cannot trigger gh's download either.
+     */
+    launchExecutable(resolved) {
+        return resolved.source === 'path' ? this.command : hook_settings_1.COPILOT_LAUNCH_COMMAND;
     }
     /**
      * Check if Copilot session is running for a worktree
@@ -96,16 +156,19 @@ class CopilotTool extends base_1.BaseCLITool {
     }
     /**
      * Start a new Copilot session for a worktree
-     * Launches `gh copilot` in interactive mode within tmux
+     * Launches copilot in interactive mode within tmux
      *
      * @param worktreeId - Worktree ID
      * @param worktreePath - Worktree path
      */
-    async startSession(worktreeId, worktreePath, instanceId) {
-        // Check if Copilot is installed
-        const copilotAvailable = await this.isInstalled();
-        if (!copilotAvailable) {
-            throw new Error('GitHub Copilot CLI is not installed. Install with: gh extension install github/gh-copilot');
+    async launchSession(worktreeId, worktreePath, instanceId) {
+        // Issue #1907: resolved once, and the same resolution decides both whether to
+        // start at all and what to type. Asking `isInstalled()` and then launching a
+        // hardcoded command is how `gh copilot` came to be sent to machines that had
+        // no copilot: the answer and the action have to come from one measurement.
+        const resolved = await (0, copilot_executable_1.resolveCopilotExecutable)();
+        if (!resolved) {
+            throw new session_start_error_1.SessionStartUnavailableError(this.name, `GitHub Copilot CLI is not installed. ${copilot_constants_1.COPILOT_INSTALL_HINT}`);
         }
         const sessionName = this.getSessionName(worktreeId, instanceId);
         // Check if session already exists
@@ -140,47 +203,151 @@ class CopilotTool extends base_1.BaseCLITool {
             // lifecycle events and Auto-Yes adjudication exist without the operator
             // having edited ~/.copilot/settings.json by hand.
             //
-            // The returned command is `gh copilot` with two environment assignments
-            // in front of it. Copilot's config is one file for the whole machine, so
-            // unlike Claude's `--settings` it cannot carry the correlation keys —
-            // they ride in the environment and the hook reads them when it fires.
-            // See `lib/hooks/sources/copilot/hook-settings`.
+            // The returned command is the resolved executable with two environment
+            // assignments in front of it. Copilot's config is one file for the whole
+            // machine, so unlike Claude's `--settings` it cannot carry the correlation
+            // keys — they ride in the environment and the hook reads them when it
+            // fires. See `lib/hooks/sources/copilot/hook-settings`.
             //
             // Fails open in every branch: with `CM_AGENT_HOOKS_INJECT=0`, or with a
-            // settings file that cannot be read or written, this is byte-for-byte the
-            // `gh copilot` this line has always sent.
+            // settings file that cannot be read or written, this is the bare launch
+            // command and nothing else.
             const launchCommand = (0, agent_session_lifecycle_1.buildAgentLaunchCommandLine)({
                 target: { worktreeId, cliToolId: tool_id_1.COPILOT_CLI_TOOL_ID, instanceId },
-                executablePath: hook_settings_1.COPILOT_LAUNCH_COMMAND,
+                executablePath: this.launchExecutable(resolved),
                 worktreePath,
             });
             // Start Copilot CLI in interactive mode
             await (0, tmux_1.sendKeys)(sessionName, launchCommand, true);
-            // Wait for Copilot to initialize
-            await new Promise((resolve) => setTimeout(resolve, COPILOT_INIT_WAIT_MS));
-            // Poll until Copilot interactive prompt is ready
+            // Issue #1907: no blind sleep before this. The 4-second one that used to
+            // sit here was a guess at how long copilot takes to paint (measured on
+            // 1.0.80: banner at ~1.3 s, folder-trust dialog at ~2.5 s), and it was
+            // load-bearing only because it hid the shell prompt from the first poll.
+            // `waitForReady` now recognises copilot's own composer rather than any
+            // `❯`, so it can start looking immediately and stop as soon as the pane is
+            // really ready.
             await this.waitForReady(sessionName);
-            logger.info('started-copilot-session');
+            logger.info('started-copilot-session', {
+                executableSource: resolved.source,
+                version: resolved.version,
+            });
         }
         catch (error) {
             const errorMessage = (0, errors_1.getErrorMessage)(error);
             throw new Error(`Failed to start Copilot session: ${errorMessage}`);
         }
     }
+    /**
+     * Answer copilot's "Confirm folder trust" dialog when the pane is sitting on
+     * it (Issue #1886).
+     *
+     * Sends the session-only option (`1. Yes`) and nothing else. Option 2 ("Yes,
+     * and remember this folder for future sessions") writes `trustedFolders` into
+     * `~/.copilot/config.json`, one file shared by every checkout on the machine,
+     * so `isCopilotFolderTrustDialog` refuses the frame outright if the list is
+     * ever reordered and `1` is no longer the session-only choice -- the same rule
+     * that makes codex's launch decline its hooks-review dialog (Issue #1760):
+     * CommandMate answers on the operator's behalf only where the answer does not
+     * write the operator's config.
+     *
+     * `sendEnter=false` because 1.0.80 confirms on the digit alone (measured on a
+     * live pane); a trailing Enter would land as an empty submit on the composer
+     * that the dismissal reveals.
+     *
+     * The capture cache is dropped afterwards because the cached frame is now
+     * wrong in a way that blocks work: a consumer reading the dialog frame reports
+     * `waiting`, and the send guard refuses a `waiting` session for as long as
+     * that entry lives.
+     *
+     * @param sessionName - tmux session name
+     * @param output - ANSI-stripped pane capture
+     * @returns True when the dialog was found and answered
+     */
+    async answerFolderTrustDialog(sessionName, output) {
+        if (!(0, cli_patterns_1.isCopilotFolderTrustDialog)(output)) {
+            return false;
+        }
+        await (0, tmux_1.sendKeys)(sessionName, cli_patterns_1.COPILOT_FOLDER_TRUST_ANSWER_KEY, false);
+        (0, tmux_capture_cache_1.invalidateCache)(sessionName);
+        logger.info('copilot-folder-trust-answered');
+        return true;
+    }
+    /**
+     * Whether copilot's own composer is drawn on the pane (Issue #1907).
+     *
+     * `COPILOT_PROMPT_PATTERN` alone answers "is there a `❯` or `>` at column 0",
+     * and a great many shell prompts are exactly that. That was harmless while a
+     * fixed 4-second sleep stood between the launch keystroke and the first poll;
+     * with the sleep gone, the very first capture is the shell echoing the launch
+     * command, and on any `❯`-prefixed prompt (starship, pure, agnoster) it would
+     * read as ready — the session would be declared started before copilot had
+     * drawn anything, and the message would be typed into a booting TUI.
+     *
+     * So readiness needs a signal that belongs to copilot rather than to whoever
+     * owns the pane. Measured on 1.0.80 at production geometry, copilot draws its
+     * composer as three rows: a full-width rule, the `❯` row, another full-width
+     * rule. Nothing else on the boot path has that shape — not the shell, not the
+     * banner-only frame, and not the folder-trust dialog, whose option rows are
+     * boxed and whose neighbours are dialog text (see
+     * `tests/fixtures/copilot-launch-boot-1080.ts`).
+     *
+     * A false negative here is the pre-existing behaviour: the loop times out,
+     * logs, and the launch continues. A false positive is a message typed into a
+     * shell, so the check is deliberately the strict one.
+     *
+     * @param output - ANSI-stripped pane capture (box drawing still present)
+     */
+    isComposerDrawn(output) {
+        const lines = output.split('\n');
+        for (let i = 1; i < lines.length - 1; i++) {
+            if (!COPILOT_COMPOSER_ROW_PATTERN.test(lines[i]))
+                continue;
+            if (cli_patterns_1.COPILOT_SEPARATOR_PATTERN.test(lines[i - 1].trimEnd()) &&
+                cli_patterns_1.COPILOT_SEPARATOR_PATTERN.test(lines[i + 1].trimEnd())) {
+                return true;
+            }
+        }
+        return false;
+    }
     /**
      * Wait for Copilot CLI to become ready (prompt visible).
-     * Polls until COPILOT_PROMPT_PATTERN is detected or max attempts reached.
+     *
+     * Readiness is asserted by seeing the composer, never by a dialog's absence:
+     * copilot draws `❯` at column 0 and removes that row entirely while a dialog
+     * is up, so a `COPILOT_PROMPT_PATTERN` match is a real input prompt and never
+     * an option row. Do NOT feed this check a `stripBoxDrawing`ed frame -- that
+     * turns the trust dialog's `│ ❯ 1. Yes` into `❯ 1. Yes` and the dialog starts
+     * reading as ready (both halves are pinned in the Issue #1886 tests).
+     *
+     * Issue #1886: on an untrusted git repository copilot shows the folder-trust
+     * dialog before anything else runs, and nothing in that frame matches the
+     * composer -- so this loop used to burn its whole 30-second window and then
+     * hand `sendMessage` a session still parked on the dialog. Answer it once and
+     * keep polling for the composer on the normal cadence; no extra sleep, and the
+     * one-shot guard means a frame that somehow still shows the dialog cannot draw
+     * a second digit.
+     *
+     * Issue #1907 tightened "composer visible" from `COPILOT_PROMPT_PATTERN` to
+     * {@link isComposerDrawn}, because with the launch path's blind sleep gone the
+     * first frame this sees is the shell that has just echoed the launch command.
+     * Both halves of the #1886 contract still hold: the boxed dialog has no `❯` at
+     * column 0, and a `stripBoxDrawing`ed dialog's `❯ 1. Yes` has dialog text
+     * either side of it rather than copilot's rules.
      */
     async waitForReady(sessionName) {
+        let trustDialogHandled = false;
         for (let i = 0; i < COPILOT_INIT_MAX_ATTEMPTS; i++) {
             try {
                 const rawOutput = await (0, tmux_1.capturePane)(sessionName, 50);
                 const output = (0, cli_patterns_1.stripAnsi)(rawOutput);
-                // Check if interactive prompt is ready
-                if (cli_patterns_1.COPILOT_PROMPT_PATTERN.test(output)) {
+                // Check if copilot's own composer is on screen
+                if (this.isComposerDrawn(output)) {
                     logger.info('copilot-prompt-detected');
                     return;
                 }
+                if (!trustDialogHandled && (await this.answerFolderTrustDialog(sessionName, output))) {
+                    trustDialogHandled = true;
+                }
             }
             catch {
                 // Capture may fail during initialization - continue polling
@@ -193,12 +360,33 @@ class CopilotTool extends base_1.BaseCLITool {
      * Wait for Copilot prompt before sending a message.
      * Used by sendMessage to ensure Copilot is ready to accept input.
      *
+     * Issue #1906 is the first change that lets a GUI/CLI send reach this wait, so
+     * what it actually costs was measured (copilot 1.0.80, private tmux socket,
+     * `tmux -L`):
+     *
+     * - **Composer on screen — idle or mid-response: ~0 ms.** copilot keeps drawing
+     *   `❯` at column 0 while it is Working, the loop captures BEFORE its first
+     *   sleep, and `COPILOT_PROMPT_PATTERN` matches immediately. A whole
+     *   `sendMessage` measured 338 ms end to end, verification included.
+     * - **Composer gone — a dialog is up: the full 15 s, then it sends anyway.**
+     *   Measured against a session parked on copilot's own `Asked user …` question:
+     *   the window expired and the body was typed into the QUESTION's input line,
+     *   which is single-line, so a four-line message arrived as
+     *   `ping oneping twoping three…`.
+     *
+     * That second case is #559's objection, and it is real — but it is not a
+     * reason to skip this method, because skipping it is what produced the same
+     * outcome in 0 ms instead of 15 s. What keeps it out of production is the layer
+     * above: `sendUserMessage` and the terminal route both consult
+     * `isPromptWaiting` (#1708/#1737) and refuse before reaching here.
+     *
      * @param sessionName - tmux session name
      * @param timeoutMs - Optional timeout in ms (default: COPILOT_PROMPT_WAIT_TIMEOUT_MS)
      */
     async waitForPrompt(sessionName, timeoutMs = COPILOT_PROMPT_WAIT_TIMEOUT_MS) {
         const startTime = Date.now();
         const pollInterval = 500;
+        let trustDialogHandled = false;
         while (Date.now() - startTime < timeoutMs) {
             try {
                 const rawOutput = await (0, tmux_1.capturePane)(sessionName, 50);
@@ -206,6 +394,18 @@ class CopilotTool extends base_1.BaseCLITool {
                 if (cli_patterns_1.COPILOT_PROMPT_PATTERN.test(output)) {
                     return;
                 }
+                // Issue #1886: `startSession` returns early for a session that already
+                // exists, so a pane adopted from outside CommandMate -- or one whose
+                // trust dialog nobody answered -- arrives here still sitting on it.
+                // Unlike codex's, this method only logs on timeout and lets the send
+                // proceed, which types the message body INTO the dialog; the body's
+                // digits are option selections there, so a message containing `2` picks
+                // "Yes, and remember this folder" and writes the operator's
+                // machine-global ~/.copilot/config.json. Answer it here for the same
+                // reason the launch path does, rather than leaving the worse outcome.
+                if (!trustDialogHandled && (await this.answerFolderTrustDialog(sessionName, output))) {
+                    trustDialogHandled = true;
+                }
             }
             catch {
                 // Capture may fail - continue polling
@@ -227,7 +427,7 @@ class CopilotTool extends base_1.BaseCLITool {
     }
     /**
      * Wait for the selection list to appear after sending a selection list command.
-     * Polls the terminal output for COPILOT_SELECTION_LIST_PATTERN.
+     * Polls the terminal output for {@link isCopilotSelectionFrame}.
      *
      * @returns true if selection list was detected, false if timed out
      */
@@ -238,9 +438,11 @@ class CopilotTool extends base_1.BaseCLITool {
         while (Date.now() - startTime < maxWaitMs) {
             await new Promise((resolve) => setTimeout(resolve, pollInterval));
             try {
+                // 50 rows is bottom-anchored (`-S -50 -E -`), which is the half of the
+                // pane `isCopilotSelectionFrame` reads. Issue #1895.
                 const rawOutput = await (0, tmux_1.capturePane)(sessionName, 50);
                 const output = (0, cli_patterns_1.stripAnsi)(rawOutput);
-                if (cli_patterns_1.COPILOT_SELECTION_LIST_PATTERN.test(output)) {
+                if ((0, cli_patterns_1.isCopilotSelectionFrame)(output.split('\n'))) {
                     logger.info('copilot-selection-list-detected');
                     return true;
                 }
@@ -287,6 +489,7 @@ class CopilotTool extends base_1.BaseCLITool {
                 sessionName,
                 message,
                 cliToolId: 'copilot',
+                composer: this.describeComposer(),
                 textInputWaitMs: copilot_constants_1.COPILOT_TEXT_INPUT_DELAY_MS,
                 verifyDelayMs: copilot_constants_1.COPILOT_SEND_ENTER_DELAY_MS,
             });
@@ -306,9 +509,17 @@ class CopilotTool extends base_1.BaseCLITool {
      * Flow:
      * 1. Verify session exists
      * 2. Send `/model <modelName>` + Enter
-     * 3. Wait for selection list to appear
-     * 4. If selection list detected, send Enter to confirm
-     * 5. Wait for prompt recovery with extended timeout
+     * 3. Wait for prompt recovery with extended timeout
+     *
+     * Steps 3 and 4 of the original flow -- wait up to 5s for the picker, then
+     * send Enter if it appeared -- are gone (Issue #1895). `/model` opens a picker
+     * only when it is given NO argument; with one it switches in place and prints
+     * `● Model changed from gpt-5.6-terra (xhigh) to gpt-5-mini (medium) for this
+     * session.` (measured on 1.0.80: the status bar carries the new model within
+     * ~300ms and the composer is back). An unknown id prints the list of valid
+     * ids and changes nothing -- also no picker. So the wait could only ever
+     * expire, and the `C-m` it guarded was a bare Enter aimed at whatever was on
+     * screen 5 seconds after a switch that had already finished.
      *
      * @param worktreeId - Worktree ID
      * @param modelName - Model name to switch to
@@ -321,14 +532,9 @@ class CopilotTool extends base_1.BaseCLITool {
             throw new Error(`Copilot session ${sessionName} does not exist. Start the session first.`);
         }
         try {
-            // Send /model <modelName> command with Enter
+            // Send /model <modelName> command with Enter. An argument means an
+            // in-place switch, never a picker (Issue #1895).
             await (0, tmux_1.sendKeys)(sessionName, `/model ${modelName}`, true);
-            // Wait for selection list to appear
-            const selectionListDetected = await this.waitForSelectionList(sessionName);
-            // If selection list appeared, send Enter to confirm the selection
-            if (selectionListDetected) {
-                await (0, tmux_1.sendSpecialKey)(sessionName, 'C-m');
-            }
             // Wait for prompt recovery with extended timeout for model switching
             await this.waitForPrompt(sessionName, copilot_constants_1.COPILOT_MODEL_SWITCH_TIMEOUT_MS);
             // Invalidate cache after model switch
@@ -343,7 +549,25 @@ class CopilotTool extends base_1.BaseCLITool {
     /**
      * Kill Copilot session
      *
+     * Issue #1905 is the first change to reach this method from the GUI / CLI at
+     * all: `POST /api/worktrees/:id/kill-session` used to call `lib/tmux`'s
+     * `killSession` directly, and the only other caller (the Assistant session
+     * route) does not allow copilot. Two things were wrong here as a result.
+     *
+     * 1. The body and Enter were batched into one `send-keys <body> C-m`. The
+     *    repository moved off that shape for message sends in #1471 because ink
+     *    TUIs swallow the trailing `C-m` as part of a bracketed paste; the exit
+     *    command is the same keystroke sequence and had been left behind.
+     * 2. `TUI_EXIT_WAIT_MS` (500 ms) was shorter than the shutdown takes on
+     *    copilot 1.0.80 — 11 measured samples ran 1.006 s to 2.193 s — so the
+     *    tmux kill always landed mid-shutdown. See {@link COPILOT_EXIT_WAIT_MS}.
+     *
+     * The `Ctrl+C` first is kept: it interrupts an in-flight generation so the
+     * composer is accepting input by the time the command is typed. tmux kill
+     * still runs unconditionally afterwards, as the fallback.
+     *
      * @param worktreeId - Worktree ID
+     * @param instanceId - Optional agent instance ID (defaults to primary)
      */
     async killSession(worktreeId, instanceId) {
         const sessionName = this.getSessionName(worktreeId, instanceId);
@@ -353,9 +577,11 @@ class CopilotTool extends base_1.BaseCLITool {
                 // 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 exit to close gracefully
-                await (0, tmux_1.sendKeys)(sessionName, 'exit', true);
-                await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.TUI_EXIT_WAIT_MS));
+                // Type the exit command, then submit it as a separate tmux command.
+                await (0, tmux_1.sendKeys)(sessionName, exports.COPILOT_EXIT_COMMAND, false);
+                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);

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

@@ -13,12 +13,15 @@ exports.GeminiTool = exports.GEMINI_PANE_HEIGHT = void 0;
 const base_1 = require("./base");
 const tmux_1 = require("../tmux/tmux");
 const submit_verified_sender_1 = require("./submit-verified-sender");
+const capture_spec_1 = require("./capture-spec");
+Object.defineProperty(exports, "GEMINI_PANE_HEIGHT", { enumerable: true, get: function () { return capture_spec_1.GEMINI_PANE_HEIGHT; } });
 const tmux_capture_cache_1 = require("../tmux/tmux-capture-cache");
 const cli_patterns_1 = require("../detection/cli-patterns");
 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 session_start_error_1 = require("../session/session-start-error");
 const logger = (0, logger_1.createLogger)('cli-tools/gemini');
 /**
  * Extract error message from unknown error type (DRY)
@@ -28,8 +31,6 @@ function getErrorMessage(error) {
 }
 /** Wait for Gemini CLI to initialize after launch (banner + auth + dialog) */
 const GEMINI_INIT_WAIT_MS = 6000;
-/** Gemini runs in a 200-line tmux pane and keeps the prompt near the top. */
-exports.GEMINI_PANE_HEIGHT = 200;
 /** Interval for polling trust dialog / prompt detection */
 const GEMINI_POLL_INTERVAL_MS = 1000;
 /** Max attempts for initialization polling (30 * 1000ms = 30s total window) */
@@ -61,11 +62,11 @@ class GeminiTool extends base_1.BaseCLITool {
      * @param worktreeId - Worktree ID
      * @param worktreePath - Worktree path
      */
-    async startSession(worktreeId, worktreePath, instanceId) {
+    async launchSession(worktreeId, worktreePath, instanceId) {
         // Check if Gemini is installed
         const geminiAvailable = await this.isInstalled();
         if (!geminiAvailable) {
-            throw new Error('Gemini CLI is not installed or not in PATH');
+            throw new session_start_error_1.SessionStartUnavailableError(this.name, 'Gemini CLI is not installed or not in PATH');
         }
         const sessionName = this.getSessionName(worktreeId, instanceId);
         // Check if session already exists
@@ -131,7 +132,7 @@ class GeminiTool extends base_1.BaseCLITool {
         let trustDialogHandled = false;
         for (let i = 0; i < GEMINI_INIT_MAX_ATTEMPTS; i++) {
             try {
-                const rawOutput = await (0, tmux_1.capturePane)(sessionName, exports.GEMINI_PANE_HEIGHT);
+                const rawOutput = await (0, tmux_1.capturePane)(sessionName, capture_spec_1.GEMINI_PANE_HEIGHT);
                 // Strip ANSI escape codes before pattern matching
                 // (Gemini TUI uses 24-bit color codes that break regex matching)
                 const output = (0, cli_patterns_1.stripAnsi)(rawOutput);
@@ -164,7 +165,7 @@ class GeminiTool extends base_1.BaseCLITool {
         const pollInterval = 500;
         while (Date.now() - startTime < GEMINI_PROMPT_WAIT_TIMEOUT_MS) {
             try {
-                const rawOutput = await (0, tmux_1.capturePane)(sessionName, exports.GEMINI_PANE_HEIGHT);
+                const rawOutput = await (0, tmux_1.capturePane)(sessionName, capture_spec_1.GEMINI_PANE_HEIGHT);
                 const output = (0, cli_patterns_1.stripAnsi)(rawOutput);
                 if (cli_patterns_1.GEMINI_PROMPT_PATTERN.test(output)) {
                     return;
@@ -199,6 +200,7 @@ class GeminiTool extends base_1.BaseCLITool {
                 sessionName,
                 message,
                 cliToolId: 'gemini',
+                composer: this.describeComposer(),
             });
             // Issue #405: Invalidate cache after sending message
             (0, tmux_capture_cache_1.invalidateCache)(sessionName);