commandmate 0.49.2 → 0.50.0

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

@@ -17,7 +17,7 @@
  * [SEC4-001].
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CopilotTool = exports.COPILOT_EXIT_COMMAND = void 0;
+exports.CopilotTool = exports.COPILOT_EXIT_COMMAND = exports.COPILOT_DIALOG_CONFIRM_MS = void 0;
 exports.isCopilotStartupLoading = isCopilotStartupLoading;
 exports.readCopilotModelSwitchOutcomes = readCopilotModelSwitchOutcomes;
 exports.judgeCopilotModelSwitch = judgeCopilotModelSwitch;
@@ -25,7 +25,10 @@ const base_1 = require("./base");
 const tmux_1 = require("../tmux/tmux");
 const submit_verified_sender_1 = require("./submit-verified-sender");
 const composer_clear_1 = require("../../lib/session/composer-clear");
+const send_attempt_types_1 = require("../../lib/session/send-attempt-types");
+const prompt_wait_dialog_1 = require("./prompt-wait-dialog");
 const tmux_capture_cache_1 = require("../tmux/tmux-capture-cache");
+const status_detector_1 = require("../detection/status-detector");
 const cli_patterns_1 = require("../detection/cli-patterns");
 const copilot_executable_1 = require("./copilot-executable");
 const copilot_constants_1 = require("../../config/copilot-constants");
@@ -35,6 +38,7 @@ 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 launch_answer_skips_1 = require("./launch-answer-skips");
 const install_hints_1 = require("./install-hints");
 const launch_window_1 = require("./launch-window");
 const launch_screen_1 = require("../../lib/session/launch-screen");
@@ -46,6 +50,19 @@ const COPILOT_POLL_INTERVAL_MS = 1000;
 const COPILOT_INIT_MAX_ATTEMPTS = 30;
 /** Timeout for waiting for prompt before sending a message */
 const COPILOT_PROMPT_WAIT_TIMEOUT_MS = 15000;
+/**
+ * How long a dialog has to stay up in {@link CopilotTool.waitForPrompt} before
+ * the wait gives up on it (Issue #4067), on {@link PROMPT_WAIT_DIALOG_CONFIRM_READS}
+ * reads in a row.
+ *
+ * A dialog waits for a person, so waiting out the 15 s (or `/model`'s 30 s)
+ * window behind it only delays the refusal — and the picker and `/model` wait
+ * holding the instance's input lock, so Auto-Yes and other writers wait too.
+ * Both thresholds must hold, so a frame caught mid-paint that reads as a
+ * dialog once does not refuse a send. The count is shared with opencode's and
+ * vibe-local's waits (Issue #4084, {@link createDialogConfirmation}).
+ */
+exports.COPILOT_DIALOG_CONFIRM_MS = prompt_wait_dialog_1.PROMPT_WAIT_DIALOG_CONFIRM_MS;
 /**
  * Copilot CLI slash commands that open a picker.
  *
@@ -263,6 +280,50 @@ function describeBottomRow(output) {
     }
     return 'an empty pane';
 }
+/**
+ * What held the pane when the wait for the composer ran out (Issue #4161), for the
+ * refusal `send` reports. Names the screen only: nothing captured goes into it, and
+ * `classifySendFailure` reads the result (see the refusals below).
+ *
+ * A dialog does not get here: the re-read before each refusal answers `prompt-waiting`.
+ *
+ * @param output - The last capture with ANSI stripped; empty when the last read failed
+ */
+function describeCopilotPaneHold(output) {
+    if (output === '')
+        return 'the pane could not be read';
+    return 'no composer on the pane: copilot may still be starting';
+}
+/**
+ * Re-read the pane and throw `recheckComposerBeforeInput`'s `prompt-waiting`
+ * refusal when a dialog is open (Issue #4040). Any other outcome — no dialog,
+ * or a re-read that failed — returns, so the caller's own refusal stands.
+ */
+async function rethrowIfDialogOpen(sessionName) {
+    try {
+        await (0, composer_clear_1.recheckComposerBeforeInput)(sessionName, 'copilot');
+    }
+    catch (error) {
+        if (error.code === send_attempt_types_1.INPUT_RECHECK_PROMPT_WAITING_CODE)
+            throw error;
+    }
+}
+/**
+ * Refuse as `prompt-waiting` after {@link CopilotTool.waitForPrompt} saw a
+ * dialog stay up for {@link COPILOT_DIALOG_CONFIRM_MS} (Issue #4067), with the
+ * re-check's `code` and the wording `classifySendFailure` reads as
+ * `prompt-waiting`. Nothing has been typed.
+ *
+ * Refused on the wait's own reads, without reading the pane once more: those
+ * reads already confirmed the dialog, and another capture (tmux's own time-out
+ * is 5 s) would keep the picker and `/model` holding the instance's input lock
+ * past the confirmation time (review of #4067).
+ */
+function refuseConfirmedDialog(sessionName) {
+    logger.warn('input-recheck-prompt-waiting', { sessionName, cliToolId: 'copilot', confirmedMs: exports.COPILOT_DIALOG_CONFIRM_MS });
+    throw Object.assign(new Error(`A prompt dialog stayed open in session ${sessionName} for ${exports.COPILOT_DIALOG_CONFIRM_MS}ms ` +
+        'while the copilot composer was awaited (re-checked under the input lock); nothing was typed (Issue #4067).'), { code: send_attempt_types_1.INPUT_RECHECK_PROMPT_WAITING_CODE });
+}
 /**
  * Copilot CLI tool implementation
  * Manages GitHub Copilot interactive sessions using tmux
@@ -435,15 +496,21 @@ class CopilotTool extends base_1.BaseCLITool {
      * @param sessionName - tmux session name
      * @param output - ANSI-stripped pane capture
      * @param readMark - {@link instanceInputReadMark} taken before `output` was read
+     * @param skips - The calling wait's record of answers that did not go out (Issue #4161)
      * @returns True when the dialog was found and answered
      */
-    async answerFolderTrustDialog(sessionName, output, readMark) {
+    async answerFolderTrustDialog(sessionName, output, readMark, skips) {
         if (!(0, cli_patterns_1.isCopilotFolderTrustDialog)(output)) {
             return false;
         }
-        const outcome = await (0, instance_input_lock_1.answerUnderInstanceInputLock)(sessionName, readMark, async () => (0, cli_patterns_1.isCopilotFolderTrustDialog)((0, cli_patterns_1.stripAnsi)(await (0, tmux_1.capturePane)(sessionName, 50))), () => (0, tmux_1.sendKeys)(sessionName, cli_patterns_1.COPILOT_FOLDER_TRUST_ANSWER_KEY, false));
+        // Issue #4189: the session's life before the answer's await; a decline of an older life writes no record for the new one.
+        const answerLife = (0, instance_input_lock_1.instanceInputAnswerSkipLife)(sessionName);
+        const outcome = await (0, instance_input_lock_1.answerUnderInstanceInputLock)(sessionName, readMark, async () => (0, cli_patterns_1.isCopilotFolderTrustDialog)((0, cli_patterns_1.stripAnsi)(await (0, tmux_1.capturePane)(sessionName, 50))), () => (0, tmux_1.sendKeys)(sessionName, cli_patterns_1.COPILOT_FOLDER_TRUST_ANSWER_KEY, false), 
+        // Issue #4189: the lock's warn of a decline, once per streak in the calling wait.
+        { repeatScope: skips });
         if (!outcome.answered) {
-            logger.info('copilot-folder-trust-answer-skipped', { reason: outcome.reason });
+            // Issue #4189: the session, so a decline after it was made again is a new one.
+            (0, launch_answer_skips_1.noteLaunchAnswerSkipped)(logger, skips, 'copilot-folder-trust-answer-skipped', { sessionName, reason: outcome.reason }, answerLife);
             return false;
         }
         (0, launch_window_1.recordLaunchDialogPress)(sessionName);
@@ -515,6 +582,7 @@ class CopilotTool extends base_1.BaseCLITool {
      */
     async waitForReady(sessionName) {
         let trustDialogHandled = false;
+        const answerSkips = (0, launch_answer_skips_1.newLaunchAnswerSkips)();
         for (let i = 0; i < COPILOT_INIT_MAX_ATTEMPTS; i++) {
             try {
                 const readMark = (0, instance_input_lock_1.instanceInputReadMark)();
@@ -525,7 +593,7 @@ class CopilotTool extends base_1.BaseCLITool {
                     logger.info('copilot-prompt-detected');
                     return;
                 }
-                if (!trustDialogHandled && (await this.answerFolderTrustDialog(sessionName, output, readMark))) {
+                if (!trustDialogHandled && (await this.answerFolderTrustDialog(sessionName, output, readMark, answerSkips))) {
                     trustDialogHandled = true;
                 }
             }
@@ -548,17 +616,18 @@ class CopilotTool extends base_1.BaseCLITool {
      *   `❯` 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…`.
+     * - **Composer gone — a dialog is up: the full 15 s.** Measured against a
+     *   session parked on copilot's own `Asked user …` question: until Issue #4040
+     *   the send then went ahead, 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…`. Now the window expiring refuses the send.
      *
      * 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.
+     * outcome in 0 ms instead of 15 s. The layer above refuses most dialogs
+     * first: `sendUserMessage` and the terminal route both consult
+     * `isPromptWaiting` (#1708/#1737), and the shared sender re-reads the pane
+     * under the input lock (#3945).
      *
      * Issue #2623 adds a third case, measured on 1.0.85: **composer on screen,
      * copilot still starting — until loading ends (3–4.5 s).** The composer is drawn
@@ -567,23 +636,49 @@ class CopilotTool extends base_1.BaseCLITool {
      * used to end this wait in 0 ms right there, which is how `send --model` on a
      * session it had just started typed a body that never ran.
      *
-     * Timing out still only logs and lets the send proceed, as before; the caller
-     * that must not proceed ({@link sendModelCommand}) reads the result.
+     * Timing out logs and returns `ready: false`; every caller reads it and types
+     * nothing then — the normal send since Issue #4040 (it used to drop the result
+     * and send anyway), the selection-list branch and {@link sendModelCommand}.
+     *
+     * Issue #4067: a dialog does not wait out the window. A frame the shared
+     * sender's re-check would refuse (`detectSessionStatus().hasActivePrompt`,
+     * {@link recheckComposerBeforeInput}) on {@link PROMPT_WAIT_DIALOG_CONFIRM_READS}
+     * reads in a row spanning {@link COPILOT_DIALOG_CONFIRM_MS} returns
+     * `ready: false, dialog: true`, and every caller refuses it as
+     * `prompt-waiting`. Not counted: the folder-trust dialog (answered above,
+     * #1886), and a frame with the composer drawn — `idle` waits through a
+     * Working turn, which keeps `❯` on screen, and that is not a dialog.
+     *
+     * Issue #4084: no capture is waited for past `timeoutMs` ({@link readBeforeDeadline}):
+     * one still running then, or one that answers after it, is not used.
      *
      * @param sessionName - tmux session name
      * @param timeoutMs - Optional timeout in ms (default: COPILOT_PROMPT_WAIT_TIMEOUT_MS)
      * @param until - What counts as ready (Issue #2623, default `composer`)
-     * @returns Whether the pane got there, and the last frame read (ANSI stripped)
+     * @returns Whether the pane got there, the last frame read (ANSI stripped),
+     *   and whether it gave up on a dialog (Issue #4067)
      */
     async waitForPrompt(sessionName, timeoutMs = COPILOT_PROMPT_WAIT_TIMEOUT_MS, until = 'composer') {
-        const startTime = Date.now();
+        // Issue #4084: one deadline for the whole wait — a capture still running at
+        // it is not waited for, and a frame it returns past it is not used.
+        const deadline = Date.now() + timeoutMs;
         const pollInterval = 500;
         let trustDialogHandled = false;
         let output = '';
-        while (Date.now() - startTime < timeoutMs) {
+        // Issue #4161: the last read failed, so `output` says nothing about the pane now.
+        let lastReadFailed = false;
+        const answerSkips = (0, launch_answer_skips_1.newLaunchAnswerSkips)();
+        // Issue #4067: the current run of reads that showed a dialog (counted by
+        // the helper opencode and vibe-local share, Issue #4084).
+        const dialog = (0, prompt_wait_dialog_1.createDialogConfirmation)();
+        while (Date.now() < deadline) {
             try {
                 const readMark = (0, instance_input_lock_1.instanceInputReadMark)();
-                const rawOutput = await (0, tmux_1.capturePane)(sessionName, 50);
+                lastReadFailed = true;
+                const rawOutput = await (0, prompt_wait_dialog_1.readBeforeDeadline)(() => (0, tmux_1.capturePane)(sessionName, 50), deadline);
+                if (rawOutput === null)
+                    break;
+                lastReadFailed = false;
                 output = (0, cli_patterns_1.stripAnsi)(rawOutput);
                 if (this.isReadyFor(until, output)) {
                     return { ready: true, output };
@@ -591,21 +686,31 @@ class CopilotTool extends base_1.BaseCLITool {
                 // 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, readMark))) {
+                // Until Issue #4040 the normal send went ahead on a timeout, which
+                // typed 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. The send now refuses instead, but answering
+                // it here (as the launch path does) is what lets that send go through.
+                if (!trustDialogHandled && (await this.answerFolderTrustDialog(sessionName, output, readMark, answerSkips))) {
                     trustDialogHandled = true;
                 }
+                if (dialog.observe(this.isRefusableDialog(rawOutput, output))) {
+                    logger.info('copilot-prompt-wait-dialog', { until, reads: dialog.reads, bottomRow: describeBottomRow(output) });
+                    return { ready: false, output, dialog: true };
+                }
             }
             catch {
-                // Capture may fail - continue polling
+                // Capture may fail - continue polling. Not a dialog read: the run restarts.
+                dialog.reset();
             }
-            await new Promise((resolve) => setTimeout(resolve, pollInterval));
+            const remaining = deadline - Date.now();
+            if (remaining <= 0)
+                break;
+            await new Promise((resolve) => setTimeout(resolve, Math.min(pollInterval, remaining)));
         }
+        if (lastReadFailed)
+            output = '';
         logger.info('copilot-prompt-not-detected', { until, bottomRow: describeBottomRow(output) });
         return { ready: false, output };
     }
@@ -620,6 +725,32 @@ class CopilotTool extends base_1.BaseCLITool {
      * @param until - What counts as ready
      * @param output - ANSI-stripped pane capture
      */
+    /**
+     * {@link isReadyFor}`('composer')` for the shared sender's read under the
+     * input lock (Issue #4040). Not `idle`: copilot draws `❯` while Working and
+     * takes a body then, as it always has.
+     */
+    inputReadiness = {
+        label: 'copilot',
+        isReady: (frame) => this.isReadyFor('composer', (0, cli_patterns_1.stripAnsi)(frame)),
+    };
+    /**
+     * Whether {@link waitForPrompt} counts this frame towards giving up on a
+     * dialog (Issue #4067): the shared sender's re-check would refuse it
+     * (`hasActivePrompt`), it is not the folder-trust dialog `waitForPrompt`
+     * answers itself (#1886), and no composer is drawn — a Working turn keeps
+     * `❯` up and is waited through, not refused.
+     *
+     * @param rawOutput - The capture as read (ANSI allowed), for the detector
+     * @param output - The same capture, ANSI stripped
+     */
+    isRefusableDialog(rawOutput, output) {
+        if ((0, cli_patterns_1.isCopilotFolderTrustDialog)(output))
+            return false;
+        if (this.isReadyFor('composer', output))
+            return false;
+        return (0, status_detector_1.detectSessionStatus)(rawOutput, 'copilot').hasActivePrompt;
+    }
     isReadyFor(until, output) {
         if (!cli_patterns_1.COPILOT_PROMPT_PATTERN.test(output))
             return false;
@@ -700,6 +831,10 @@ class CopilotTool extends base_1.BaseCLITool {
                     // then refuses on the same terms right before the keys: a dialog is
                     // `prompt-waiting`, a pane that cannot be read `recheck-failed`.
                     const prompt = await this.waitForPrompt(sessionName);
+                    // Issue #4067: a dialog that stayed up is refused at once — the lock
+                    // is not held for the rest of the window behind it.
+                    if (prompt.dialog)
+                        refuseConfirmedDialog(sessionName);
                     await (0, composer_clear_1.recheckComposerBeforeInput)(sessionName, 'copilot');
                     if (!prompt.ready) {
                         // review-3: neither the request nor the pane goes into the message.
@@ -711,7 +846,7 @@ class CopilotTool extends base_1.BaseCLITool {
                             bottomRow: describeBottomRow(prompt.output),
                         });
                         throw new Error(`copilot prompt not ready within ${COPILOT_PROMPT_WAIT_TIMEOUT_MS}ms, ` +
-                            'so the selection-list command was not sent; nothing was typed');
+                            `so the selection-list command was not sent; nothing was typed (${describeCopilotPaneHold(prompt.output)})`);
                     }
                     assertCopilotInputOwner(ticket, 'the selection-list command');
                     // Issue #3953: the send's stamp, as the shared sender takes it.
@@ -723,8 +858,25 @@ class CopilotTool extends base_1.BaseCLITool {
                 logger.info('sent-selection-list-command-to-copilot', { command: slashCmd });
                 return;
             }
-            // Verify Copilot is at prompt state before sending
-            await this.waitForPrompt(sessionName);
+            // Verify Copilot is at prompt state before sending. Issue #4040: a
+            // composer that never came up is not typed into — refused as the
+            // selection-list branch refuses (review-3: neither the body nor the pane
+            // goes into the message, which `classifySendFailure` reads).
+            const prompt = await this.waitForPrompt(sessionName);
+            if (!prompt.ready) {
+                // Issue #4067: the wait gave up on a dialog after its confirmation time
+                // rather than the whole 15 s window.
+                if (prompt.dialog)
+                    refuseConfirmedDialog(sessionName);
+                // A dialog that opened during the wait and is still up is refused as
+                // the shared sender's re-check refuses it — `prompt-waiting` (409
+                // PROMPT_WAITING), not `prompt-not-ready`. A re-read that fails is
+                // left to the refusal below.
+                await rethrowIfDialogOpen(sessionName);
+                logger.warn('copilot-message-not-sent:prompt-not-ready', { bottomRow: describeBottomRow(prompt.output) });
+                throw new Error(`copilot prompt not ready within ${COPILOT_PROMPT_WAIT_TIMEOUT_MS}ms, ` +
+                    `so the message was not sent; nothing was typed (${describeCopilotPaneHold(prompt.output)})`);
+            }
             // Issue #1471: Body/Enter separation + read-back submit verification via the
             // shared helper (replaces the old type -> C-m -> `\n`-gated paste recovery).
             // Copilot's own text-input / post-Enter delays are preserved. The selection
@@ -736,6 +888,8 @@ class CopilotTool extends base_1.BaseCLITool {
                 composer: this.describeComposer(),
                 textInputWaitMs: copilot_constants_1.COPILOT_TEXT_INPUT_DELAY_MS,
                 verifyDelayMs: copilot_constants_1.COPILOT_SEND_ENTER_DELAY_MS,
+                // Issue #4040: the same test, of the newest frame read under the lock.
+                readiness: this.inputReadiness,
             });
             // Invalidate cache after sending message
             (0, tmux_capture_cache_1.invalidateCache)(sessionName);
@@ -822,6 +976,10 @@ class CopilotTool extends base_1.BaseCLITool {
         await (0, instance_input_lock_1.waitOutCarriedPasteMark)(ticket);
         const idle = await this.waitForPrompt(sessionName, copilot_constants_1.COPILOT_MODEL_SWITCH_TIMEOUT_MS, 'idle');
         if (!idle.ready) {
+            // Issue #4067: a dialog is refused after its confirmation time, not after
+            // the 30 s window under the lock.
+            if (idle.dialog)
+                refuseConfirmedDialog(sessionName);
             // The pane's text goes to the log, not the message: the message is read by
             // `classifySendFailure`, which a screen quoting its keywords would steer (#3954).
             logger.warn('copilot-model-switch-not-idle', { model: modelName, bottomRow: describeBottomRow(idle.output) });

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

@@ -20,10 +20,12 @@ 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 launch_answer_skips_1 = require("./launch-answer-skips");
 const cli_tool_timing_config_1 = require("../../config/cli-tool-timing-config");
 const launch_screen_1 = require("../../lib/session/launch-screen");
 const errors_1 = require("../../lib/errors");
 const launch_dialog_1 = require("./launch-dialog");
+const status_detector_1 = require("../detection/status-detector");
 const launch_window_1 = require("./launch-window");
 const instance_input_lock_1 = require("../../lib/session/instance-input-lock");
 const logger = (0, logger_1.createLogger)('cli-tools/gemini');
@@ -42,6 +44,30 @@ const GEMINI_INIT_MAX_ATTEMPTS = 30;
 const GEMINI_TRUST_SETTLE_MS = 5000;
 /** Timeout for waiting for prompt before sending a message */
 const GEMINI_PROMPT_WAIT_TIMEOUT_MS = 15000;
+/** The sign-in picker a new HOME gets after the trust restart (`tests/fixtures/gemini-live-3776/after-enter-auth.txt`). */
+const GEMINI_AUTH_PICKER_ROW = /^[\s│]*How would you like to authenticate\b/m;
+/**
+ * What held the pane when the wait for the prompt ran out (Issue #4146), for the
+ * refusal `send` reports. Names the screen only: nothing captured goes into it.
+ *
+ * @param output - The last capture with ANSI stripped; null when the last read failed
+ */
+function describeGeminiPaneHold(output) {
+    if (output === null)
+        return 'the pane could not be read';
+    if ((0, launch_dialog_1.isLaunchDialogOpen)(launch_dialog_1.GEMINI_TRUST_LAUNCH_DIALOG, output)) {
+        return 'the folder-trust dialog is open: answer it in the terminal';
+    }
+    if (GEMINI_AUTH_PICKER_ROW.test(output)) {
+        return 'the sign-in picker is open: answer it in the terminal';
+    }
+    const status = (0, status_detector_1.detectSessionStatus)(output, 'gemini');
+    if (status.hasActivePrompt)
+        return 'a prompt dialog is open: answer it in the terminal';
+    if ((0, status_detector_1.isGeneratingStatus)(status))
+        return 'a turn is still being generated';
+    return 'no input prompt on the pane: gemini may still be starting';
+}
 /**
  * Gemini CLI tool implementation
  * Manages Gemini interactive sessions using tmux
@@ -143,6 +169,7 @@ class GeminiTool extends base_1.BaseCLITool {
         let trustDialogHandled = false;
         let trustPressedAt = null;
         const loggedDecisions = new Set();
+        const answerSkips = (0, launch_answer_skips_1.newLaunchAnswerSkips)();
         for (let i = 0; i < GEMINI_INIT_MAX_ATTEMPTS; i++) {
             try {
                 // Issue #3975: taken before the read the trust Enter is decided on.
@@ -163,10 +190,14 @@ class GeminiTool extends base_1.BaseCLITool {
                         // Issue #3975: the Enter as an `exclusive` writer, so it never lands
                         // inside a send's body, paste or Enter; a send that came between
                         // the read and the lock makes the dialog be read again first.
+                        // Issue #4189: the session's life before the answer's await; a decline of an older life writes no record for the new one.
+                        const answerLife = (0, instance_input_lock_1.instanceInputAnswerSkipLife)(sessionName);
                         const pressed = await (0, instance_input_lock_1.answerUnderInstanceInputLock)(sessionName, readMark, async () => {
                             const again = (0, launch_dialog_1.decideLaunchDialog)(launch_dialog_1.GEMINI_TRUST_LAUNCH_DIALOG, (0, cli_patterns_1.stripAnsi)(await (0, tmux_1.capturePane)(sessionName, capture_spec_1.GEMINI_PANE_HEIGHT)));
                             return again.action === 'press' && again.key === decision.key;
-                        }, () => (0, tmux_1.sendSpecialKey)(sessionName, decision.key), { mode: 'exclusive' });
+                        }, () => (0, tmux_1.sendSpecialKey)(sessionName, decision.key), 
+                        // Issue #4189: the lock's warn of a decline, once per streak in this wait.
+                        { mode: 'exclusive', repeatScope: answerSkips });
                         if (pressed.answered) {
                             trustDialogHandled = true;
                             trustPressedAt = Date.now();
@@ -178,7 +209,7 @@ class GeminiTool extends base_1.BaseCLITool {
                         }
                         else {
                             // Not answered this poll; the next one reads the screen again.
-                            logger.info('gemini-trust-answer-skipped', { sessionName, reason: pressed.reason });
+                            (0, launch_answer_skips_1.noteLaunchAnswerSkipped)(logger, answerSkips, 'gemini-trust-answer-skipped', { sessionName, reason: pressed.reason }, answerLife);
                         }
                     }
                     else {
@@ -215,16 +246,19 @@ class GeminiTool extends base_1.BaseCLITool {
     async waitForPrompt(sessionName) {
         const startTime = Date.now();
         const pollInterval = 500;
+        let lastOutput = null;
         while (Date.now() - startTime < GEMINI_PROMPT_WAIT_TIMEOUT_MS) {
             try {
                 const rawOutput = await (0, tmux_1.capturePane)(sessionName, capture_spec_1.GEMINI_PANE_HEIGHT);
                 const output = (0, cli_patterns_1.stripAnsi)(rawOutput);
+                lastOutput = output;
                 if (cli_patterns_1.GEMINI_PROMPT_PATTERN.test(output)) {
                     return;
                 }
             }
             catch (error) {
                 // Capture may fail - continue polling
+                lastOutput = null;
                 logger.debug('gemini-prompt-capture-failed', { sessionName, error: (0, errors_1.getErrorMessage)(error) });
             }
             await new Promise((resolve) => setTimeout(resolve, pollInterval));
@@ -232,7 +266,7 @@ class GeminiTool extends base_1.BaseCLITool {
         // Issue #3981: give up without typing, as codex does. Sending anyway put the
         // body into whatever held the pane (a dialog, a slow start, a shell).
         logger.info('gemini-prompt-not-detected');
-        throw new Error('Gemini prompt not ready: timed out waiting for the input prompt before sending');
+        throw new Error(`Gemini prompt not ready: timed out waiting for the input prompt before sending (${describeGeminiPaneHold(lastOutput)})`);
     }
     /**
      * Send a message to Gemini interactive session

package/dist/server/src/lib/cli-tools/launch-answer-skips.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * Launch answers that did not go out (Issue #4161).
+ *
+ * The automatic answer to a launch screen goes through the instance input lock,
+ * which can decline it, and the screen is due again on every poll. The record of
+ * that is a warn, as the Claude trust dialog's is (#4149): at info a WARN- or
+ * ERROR-only setting left no trace of a start that sent nothing. It is written
+ * once while the same reason goes on, per event, per wait.
+ *
+ * @module lib/cli-tools/launch-answer-skips
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newLaunchAnswerSkips = newLaunchAnswerSkips;
+exports.noteLaunchAnswerSkipped = noteLaunchAnswerSkipped;
+exports.forgetLaunchAnswerSkip = forgetLaunchAnswerSkip;
+const instance_input_lock_1 = require("../../lib/session/instance-input-lock");
+function newLaunchAnswerSkips() {
+    return { byEvent: new Map(), last: null, lastEvent: null, lifeByEvent: new Map() };
+}
+/**
+ * Record a declined answer at warn, unless the same reason was the last under `event`
+ * in the same life of the session (Issue #4189: `fields.sessionName`; without it
+ * the life is not compared, as before).
+ *
+ * The life is the one the answer started in (`startedIn`, taken before its await),
+ * as the input lock judges its own warn: a decline of an older life — the session
+ * was made again while it waited or read the screen again — is written, but neither
+ * reads nor writes the record of the new life. Without `startedIn` the life at this
+ * call is used.
+ *
+ * @param logger - The caller's logger, so the record keeps its module
+ * @param skips - This wait's record
+ * @param event - The log event, one per kind of answer
+ * @param fields - The log fields; `reason` is an enum, nothing captured goes in
+ * @param startedIn - {@link instanceInputAnswerSkipLife} of `fields.sessionName`, taken before the answer
+ */
+function noteLaunchAnswerSkipped(logger, skips, event, fields, startedIn) {
+    const sessionName = typeof fields.sessionName === 'string' ? fields.sessionName : null;
+    if (sessionName !== null && startedIn !== undefined && !(0, instance_input_lock_1.isInstanceInputAnswerSkipLife)(sessionName, startedIn)) {
+        // An answer of an older life: its warn, and no record for the new one.
+        logger.warn(event, fields);
+        skips.last = fields.reason;
+        skips.lastEvent = event;
+        return;
+    }
+    const recorded = skips.lifeByEvent.get(event);
+    const sameLife = recorded === undefined ||
+        (recorded.sessionName === sessionName && (0, instance_input_lock_1.isInstanceInputAnswerSkipLife)(recorded.sessionName, recorded.life));
+    if (skips.byEvent.get(event) !== fields.reason || !sameLife)
+        logger.warn(event, fields);
+    skips.byEvent.set(event, fields.reason);
+    if (sessionName === null)
+        skips.lifeByEvent.delete(event);
+    else
+        skips.lifeByEvent.set(event, { sessionName, life: startedIn ?? (0, instance_input_lock_1.instanceInputAnswerSkipLife)(sessionName) });
+    skips.last = fields.reason;
+    skips.lastEvent = event;
+}
+/**
+ * Forget what was declined under `event`: the answer went through, or the screen it
+ * was for has gone. The record describes a key that has not gone out, so a refusal
+ * must not repeat it after that, and a later decline is a new one to report, even
+ * for the same reason. Other events' records are theirs.
+ *
+ * @param skips - This wait's record
+ * @param event - The log event the answer belongs to
+ */
+function forgetLaunchAnswerSkip(skips, event) {
+    skips.byEvent.delete(event);
+    skips.lifeByEvent.delete(event);
+    if (skips.lastEvent === event) {
+        skips.last = null;
+        skips.lastEvent = null;
+    }
+}

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

@@ -51,6 +51,7 @@ const errors_1 = require("../../lib/errors");
 const agent_session_lifecycle_1 = require("../../lib/session/agent-session-lifecycle");
 const runtime_1 = require("../../lib/hooks/sources/opencode-v2/runtime");
 const client_1 = require("../../lib/hooks/sources/opencode-v2/client");
+const secrets_1 = require("../../lib/hooks/sources/opencode-v2/secrets");
 const ports_1 = require("../../lib/hooks/sources/opencode-v2/ports");
 const subscription_1 = require("../../lib/hooks/sources/opencode-v2/subscription");
 const tool_id_1 = require("../../lib/hooks/sources/opencode-v2/tool-id");
@@ -247,6 +248,15 @@ class OpenCodeV2Tool extends base_1.BaseCLITool {
             throw new Error(`Failed to start OpenCode V2 session: ${(0, errors_1.getErrorMessage)(error)}`);
         }
     }
+    /** Issue #4115: `GET /api/config`, the evidence that the server read the role (§14). */
+    async readServerConfig(worktreeId, worktreePath, instanceId) {
+        const target = (0, runtime_1.opencodeV2Target)(worktreeId, instanceId);
+        const port = (0, ports_1.getAssignedOpencodeV2Port)(target);
+        const password = (0, secrets_1.readOpencodeV2Password)(target);
+        if (port === null || password === null)
+            return null;
+        return (0, client_1.fetchOpencodeV2Config)(port, password, worktreePath);
+    }
     /** Poll until the composer is on screen (or give up quietly). */
     async waitForReady(sessionName) {
         for (let attempt = 0; attempt < exports.OPENCODE_V2_READY_MAX_ATTEMPTS; attempt++) {