commandmate 0.46.0 → 0.47.0

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

@@ -21,6 +21,9 @@ 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 frame_1 = require("../detection/tools/frame");
+const patterns_1 = require("../detection/tools/antigravity/patterns");
+const antigravity_startup_trust_1 = require("./antigravity-startup-trust");
+const launch_dialog_1 = require("./launch-dialog");
 const sources_1 = require("../../lib/hooks/sources");
 const agent_session_lifecycle_1 = require("../../lib/session/agent-session-lifecycle");
 const logger_1 = require("../../lib/logger");
@@ -61,16 +64,49 @@ const ANTIGRAVITY_PROMPT_WAIT_TIMEOUT_MS = 15000;
  */
 const ANTIGRAVITY_READY_FOOTER_PATTERN = /\?\s+for\s+shortcuts/;
 /**
- * Startup trust dialog marker (Issue #988). On first access to an untrusted
- * folder agy shows:
- *   Do you trust the contents of this project?
- *   > Yes, I trust this folder   <- default-selected option
- *     No, exit
- *   ↑/↓ Navigate · enter Confirm
- * "Yes, I trust this folder" is the default selection, so a single Enter confirms
- * it. (Confirmed on machine.)
+ * How long a send waits for the prompt while the launch's trust Enter is still
+ * owed (Issue #3757). agy was measured drawing the trust screen 61 s after the
+ * launch, ~27 s after the launch window ended; 60 s covers that with room.
  */
-const ANTIGRAVITY_TRUST_DIALOG_PATTERN = /Do you trust the contents of this project\?/;
+const ANTIGRAVITY_STARTUP_PROMPT_WAIT_TIMEOUT_MS = 60000;
+/** Rows of the last capture a timeout log quotes, each cut to {@link SCREEN_TAIL_MAX_CHARS}. */
+const SCREEN_TAIL_ROWS = 5;
+const SCREEN_TAIL_MAX_CHARS = 160;
+/**
+ * What a readiness wait saw last, for its timeout log (Issue #3757): which of
+ * the screens it knows the pane showed, and its last few non-blank rows.
+ */
+function describeScreen(output) {
+    if (output === null)
+        return { screen: 'no-capture', screenTail: [] };
+    const rows = (0, cli_patterns_1.stripAnsi)(output)
+        .split('\n')
+        .map((row) => row.trimEnd())
+        .filter((row) => row.trim() !== '');
+    const lastLines = (0, frame_1.normalizeFrame)(output, 'antigravity').lastLines;
+    const screen = rows.length === 0
+        ? 'blank'
+        : (0, patterns_1.isAntigravityTrustScreen)(lastLines)
+            ? 'trust-dialog'
+            : isAntigravityReady(output)
+                ? 'ready'
+                : 'other';
+    return {
+        screen,
+        screenTail: rows.slice(-SCREEN_TAIL_ROWS).map((row) => row.slice(0, SCREEN_TAIL_MAX_CHARS)),
+    };
+}
+/**
+ * Log, once per reason per wait, why a trust screen was left without its Enter
+ * (Issue #3776). Names the dialog and the cursor's row, never the screen.
+ */
+function logTrustDecisionOnce(sessionName, decision, logged) {
+    const warning = (0, launch_dialog_1.launchDialogWarning)(launch_dialog_1.ANTIGRAVITY_TRUST_LAUNCH_DIALOG, decision);
+    if (!warning || decision.action === 'absent' || decision.action === 'press' || logged.has(decision.reason))
+        return;
+    logged.add(decision.reason);
+    logger.warn(warning.event, { sessionName, ...warning.fields });
+}
 /**
  * Read agy's input box off the bottom of a frame (Issue #2478).
  *
@@ -146,7 +182,7 @@ function isAntigravityReady(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))
+    if (patterns_1.ANTIGRAVITY_TRUST_DIALOG_PATTERN.test(frame.lastLines))
         return false;
     const statusRow = readInputBoxStatusRow(frame.contentLines);
     if (statusRow === null)
@@ -226,11 +262,19 @@ class AntigravityTool extends base_1.BaseCLITool {
                 // (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));
-            // Poll until the interactive prompt is ready (handles the trust dialog)
-            await this.waitForReady(sessionName);
+            // Issue #3757: from the launch line to the end of `waitForReady`, a trust
+            // screen is this window's to confirm; the poller records nothing for it.
+            (0, antigravity_startup_trust_1.beginStartupWindow)(sessionName);
+            try {
+                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));
+                // Poll until the interactive prompt is ready (handles the trust dialog)
+                await this.waitForReady(sessionName);
+            }
+            finally {
+                (0, antigravity_startup_trust_1.endStartupWindow)(sessionName);
+            }
             logger.info('started-antigravity-session');
         }
         catch (error) {
@@ -243,61 +287,148 @@ class AntigravityTool extends base_1.BaseCLITool {
      * Handles the first-run trust dialog ("Do you trust the contents of this
      * project?") by sending Enter to confirm the default "Yes, I trust this folder"
      * selection. Polls until {@link isAntigravityReady} or max attempts reached.
+     *
+     * Issue #3757: the window can end before agy has drawn anything — its start
+     * up was measured at 1 s on one launch and 61 s on the next. The launch still
+     * succeeds, but a window that never sent its Enter now records it as owed
+     * (`antigravity-startup-trust`), so the next send's {@link waitForPrompt}
+     * delivers it once; and the timeout log says what the pane showed and what
+     * the captures threw instead of swallowing both.
      */
     async waitForReady(sessionName) {
+        // A relaunch starts over: whatever an earlier process of this pane owed is
+        // not this one's.
+        (0, antigravity_startup_trust_1.forgetStartupTrust)(sessionName);
         // One-shot guard: capturePane keeps the dismissed dialog in scrollback, so
         // Enter must be sent at most once per dialog.
         let trustDialogHandled = false;
+        const loggedTrustDecisions = new Set();
+        let lastOutput = null;
+        let captureErrors = 0;
+        let lastCaptureError;
         for (let i = 0; i < ANTIGRAVITY_INIT_MAX_ATTEMPTS; i++) {
             try {
                 const rawOutput = await (0, tmux_1.capturePane)(sessionName, 50);
                 const output = (0, cli_patterns_1.stripAnsi)(rawOutput);
+                lastOutput = rawOutput;
                 // Ready: the input box is live and no agy screen covers it.
                 if (isAntigravityReady(output)) {
                     logger.info('antigravity-prompt-detected');
                     return;
                 }
-                // Trust dialog: confirm the default "Yes, I trust this folder" with Enter.
-                if (!trustDialogHandled && ANTIGRAVITY_TRUST_DIALOG_PATTERN.test(output)) {
-                    await (0, tmux_1.sendSpecialKey)(sessionName, 'Enter');
-                    trustDialogHandled = true;
-                    logger.info('auto-trusted-folder-for-antigravity');
-                    await new Promise((resolve) => setTimeout(resolve, ANTIGRAVITY_DIALOG_SETTLE_MS));
-                    continue;
+                // Trust dialog: confirm the default "Yes, I trust this folder" with
+                // Enter — only while the cursor is on it (Issue #3776), and not while a
+                // strict `respond` holds the session (Issue #3771): the screen is its to
+                // key, and the window looks again after a poll.
+                if (!trustDialogHandled) {
+                    const decision = (0, launch_dialog_1.decideLaunchDialog)(launch_dialog_1.ANTIGRAVITY_TRUST_LAUNCH_DIALOG, output);
+                    if (decision.action === 'press' && !(0, antigravity_startup_trust_1.isStartupTrustHeld)(sessionName)) {
+                        await (0, tmux_1.sendSpecialKey)(sessionName, decision.key);
+                        trustDialogHandled = true;
+                        logger.info('auto-trusted-folder-for-antigravity');
+                        await new Promise((resolve) => setTimeout(resolve, ANTIGRAVITY_DIALOG_SETTLE_MS));
+                        continue;
+                    }
+                    logTrustDecisionOnce(sessionName, decision, loggedTrustDecisions);
                 }
             }
-            catch {
-                // Capture may fail during initialization - continue polling
+            catch (error) {
+                // Capture may fail during initialization - continue polling, but keep
+                // count so the timeout below can say so (Issue #3757).
+                captureErrors++;
+                lastCaptureError = (0, errors_1.getErrorMessage)(error);
             }
             await new Promise((resolve) => setTimeout(resolve, ANTIGRAVITY_POLL_INTERVAL_MS));
         }
-        logger.info('antigravity-prompt-detection-timeout');
+        // Issue #3757: the Enter is owed only when this window sent none. One that
+        // did must never be followed by a second one.
+        if (!trustDialogHandled)
+            (0, antigravity_startup_trust_1.markStartupTrustPending)(sessionName);
+        logger.info('antigravity-prompt-detection-timeout', {
+            sessionName,
+            attempts: ANTIGRAVITY_INIT_MAX_ATTEMPTS,
+            trustDialogHandled,
+            ...(trustDialogHandled ? {} : { reason: 'startup-trust-unhandled' }),
+            ...describeScreen(lastOutput),
+            captureErrors,
+            ...(lastCaptureError !== undefined ? { lastCaptureError } : {}),
+        });
     }
     /**
      * Wait for agy's prompt before sending a message.
      * Mirrors CodexTool.waitForPrompt: throws on timeout so a failed readiness
      * check STOPS the send rather than typing into a non-ready TUI.
      *
+     * Issue #3757: while the launch's trust Enter is still owed
+     * ({@link waitForReady}'s window ended first), the wait is
+     * {@link ANTIGRAVITY_STARTUP_PROMPT_WAIT_TIMEOUT_MS} long and the trust screen,
+     * when it shows up live, gets that one Enter — claimed, so a second send
+     * waiting on the same pane cannot send another. A timeout says when it was
+     * the unconfirmed trust screen that kept the prompt away.
+     *
      * @throws Error when the input prompt is not detected within the timeout
      */
     async waitForPrompt(sessionName) {
         const startTime = Date.now();
+        let deadline = startTime + ((0, antigravity_startup_trust_1.isStartupTrustPending)(sessionName)
+            ? ANTIGRAVITY_STARTUP_PROMPT_WAIT_TIMEOUT_MS
+            : ANTIGRAVITY_PROMPT_WAIT_TIMEOUT_MS);
         const pollInterval = 500;
-        while (Date.now() - startTime < ANTIGRAVITY_PROMPT_WAIT_TIMEOUT_MS) {
+        const loggedTrustDecisions = new Set();
+        let lastOutput = null;
+        let captureErrors = 0;
+        let lastCaptureError;
+        while (Date.now() < deadline) {
             try {
                 const rawOutput = await (0, tmux_1.capturePane)(sessionName, 50);
                 const output = (0, cli_patterns_1.stripAnsi)(rawOutput);
+                lastOutput = rawOutput;
                 if (isAntigravityReady(output)) {
+                    (0, antigravity_startup_trust_1.forgetStartupTrust)(sessionName);
                     return;
                 }
+                // Issue #3776: the owed Enter is claimed only while the cursor is on
+                // `Yes, I trust this folder`; otherwise it stays owed and unsent.
+                const trustDecision = (0, patterns_1.isAntigravityTrustScreen)((0, frame_1.normalizeFrame)(output, 'antigravity').lastLines)
+                    ? (0, launch_dialog_1.decideLaunchDialog)(launch_dialog_1.ANTIGRAVITY_TRUST_LAUNCH_DIALOG, output)
+                    : null;
+                if (trustDecision !== null && trustDecision.action !== 'press' && (0, antigravity_startup_trust_1.isStartupTrustPending)(sessionName)) {
+                    logTrustDecisionOnce(sessionName, trustDecision, loggedTrustDecisions);
+                }
+                if (trustDecision?.action === 'press' && (0, antigravity_startup_trust_1.claimStartupTrust)(sessionName)) {
+                    await (0, tmux_1.sendSpecialKey)(sessionName, trustDecision.key);
+                    logger.info('auto-trusted-folder-for-antigravity', { sessionName, afterLaunchWindow: true });
+                    // A full ordinary window for agy to draw its prompt after the Enter.
+                    deadline = Math.max(deadline, Date.now() + ANTIGRAVITY_PROMPT_WAIT_TIMEOUT_MS);
+                    await new Promise((resolve) => setTimeout(resolve, ANTIGRAVITY_DIALOG_SETTLE_MS));
+                    continue;
+                }
             }
-            catch {
+            catch (error) {
                 // Capture may fail - continue polling
+                captureErrors++;
+                lastCaptureError = (0, errors_1.getErrorMessage)(error);
             }
             await new Promise((resolve) => setTimeout(resolve, pollInterval));
         }
-        logger.info('antigravity-prompt-not-ready');
-        throw new Error('Antigravity prompt not ready: timed out waiting for the input prompt before sending');
+        const trustPending = (0, antigravity_startup_trust_1.isStartupTrustPending)(sessionName);
+        const seen = describeScreen(lastOutput);
+        logger.info('antigravity-prompt-not-ready', {
+            sessionName,
+            waitedMs: Date.now() - startTime,
+            ...(trustPending ? { reason: 'startup-trust-unhandled' } : {}),
+            ...seen,
+            captureErrors,
+            ...(lastCaptureError !== undefined ? { lastCaptureError } : {}),
+        });
+        // A live trust screen here is one whose Enter was already sent (or never
+        // owed): it is a human's now.
+        const cause = seen.screen === 'trust-dialog'
+            ? ' (the folder-trust confirmation "Do you trust the contents of this project?" is on screen and needs an answer)'
+            : trustPending
+                ? ' (startup-trust-unhandled: agy had not shown its folder-trust confirmation when the launch window ended, and it has not appeared since)'
+                : '';
+        throw new Error(`Antigravity prompt not ready: timed out waiting for the input prompt before sending${cause}`);
     }
     /**
      * Send a message to the Antigravity session.
@@ -351,6 +482,8 @@ class AntigravityTool extends base_1.BaseCLITool {
             afterKill: (sessionName) => {
                 // Invalidate cache so a later session reusing the name starts clean
                 (0, tmux_capture_cache_1.invalidateCache)(sessionName);
+                // Issue #3757: an Enter owed to the killed process is not the next one's.
+                (0, antigravity_startup_trust_1.forgetStartupTrust)(sessionName);
             },
         });
     }

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

@@ -47,6 +47,7 @@ const tmux_capture_cache_1 = require("../tmux/tmux-capture-cache");
 const cli_patterns_1 = require("../detection/cli-patterns");
 const errors_1 = require("../../lib/errors");
 const logger_1 = require("../../lib/logger");
+const send_attempt_types_1 = require("../../lib/session/send-attempt-types");
 const tool_id_1 = require("../../lib/hooks/sources/command-code/tool-id");
 const agent_session_lifecycle_1 = require("../../lib/session/agent-session-lifecycle");
 const cli_tool_timing_config_1 = require("../../config/cli-tool-timing-config");
@@ -319,7 +320,9 @@ class CommandCodeTool extends base_1.BaseCLITool {
             planReviewPolls = planReviewUp ? planReviewPolls + 1 : 0;
             if (planReviewPolls >= 2) {
                 logger.info('command-code-plan-review-blocks-send', { sessionName });
-                throw new Error(exports.COMMAND_CODE_PLAN_REVIEW_SEND_MESSAGE);
+                throw Object.assign(new Error(exports.COMMAND_CODE_PLAN_REVIEW_SEND_MESSAGE), {
+                    code: send_attempt_types_1.PLAN_REVIEW_SEND_REFUSED_CODE,
+                });
             }
             await new Promise((resolve) => setTimeout(resolve, pollInterval));
         }
@@ -365,7 +368,12 @@ class CommandCodeTool extends base_1.BaseCLITool {
             // Issue #3006: passed through unwrapped so its `code` reaches the route.
             if ((0, session_start_error_1.isSessionStartTimeoutError)(error))
                 throw error;
-            throw new Error(`Failed to send message to Command Code: ${(0, errors_1.getErrorMessage)(error)}`);
+            const wrapped = new Error(`Failed to send message to Command Code: ${(0, errors_1.getErrorMessage)(error)}`);
+            // Issue #3772: the plan review refusal comes before the body; keep its code.
+            if (error?.code === send_attempt_types_1.PLAN_REVIEW_SEND_REFUSED_CODE) {
+                throw Object.assign(wrapped, { code: send_attempt_types_1.PLAN_REVIEW_SEND_REFUSED_CODE });
+            }
+            throw wrapped;
         }
     }
     /**

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

@@ -35,6 +35,7 @@ const tool_id_1 = require("../../lib/hooks/sources/copilot/tool-id");
 const errors_1 = require("../../lib/errors");
 const logger_1 = require("../../lib/logger");
 const install_hints_1 = require("./install-hints");
+const launch_window_1 = require("./launch-window");
 const launch_screen_1 = require("../../lib/session/launch-screen");
 const logger = (0, logger_1.createLogger)('cli-tools/copilot');
 /** Interval for polling prompt detection */
@@ -345,16 +346,25 @@ class CopilotTool extends base_1.BaseCLITool {
             if (!exists) {
                 await this.createLaunchPane(sessionName, worktreePath);
             }
-            // Start Copilot CLI in interactive mode
-            await (0, tmux_1.sendKeys)(sessionName, (0, launch_screen_1.withLaunchScreenCleared)(launchCommand), true);
-            // Issue #1907: no blind sleep before this. The 4-second one that used to
-            // 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);
+            // Issue #3790: from the launch line to the end of `waitForReady`, the
+            // folder-trust dialog is this launch's to answer; the Auto-Yes poller
+            // leaves it (`cli-tools/launch-window`).
+            (0, launch_window_1.beginLaunchWindow)(sessionName);
+            try {
+                // Start Copilot CLI in interactive mode
+                await (0, tmux_1.sendKeys)(sessionName, (0, launch_screen_1.withLaunchScreenCleared)(launchCommand), true);
+                // Issue #1907: no blind sleep before this. The 4-second one that used to
+                // 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);
+            }
+            finally {
+                (0, launch_window_1.endLaunchWindow)(sessionName);
+            }
             logger.info('started-copilot-session', {
                 executableSource: resolved.source,
                 version: resolved.version,
@@ -396,6 +406,7 @@ class CopilotTool extends base_1.BaseCLITool {
             return false;
         }
         await (0, tmux_1.sendKeys)(sessionName, cli_patterns_1.COPILOT_FOLDER_TRUST_ANSWER_KEY, false);
+        (0, launch_window_1.recordLaunchDialogPress)(sessionName);
         (0, tmux_capture_cache_1.invalidateCache)(sessionName);
         logger.info('copilot-folder-trust-answered');
         return true;

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

@@ -23,6 +23,8 @@ const logger_1 = require("../../lib/logger");
 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 launch_window_1 = require("./launch-window");
 const logger = (0, logger_1.createLogger)('cli-tools/gemini');
 /** Wait for Gemini CLI to initialize after launch (banner + auth + dialog) */
 const GEMINI_INIT_WAIT_MS = 6000;
@@ -30,6 +32,13 @@ const GEMINI_INIT_WAIT_MS = 6000;
 const GEMINI_POLL_INTERVAL_MS = 1000;
 /** Max attempts for initialization polling (30 * 1000ms = 30s total window) */
 const GEMINI_INIT_MAX_ATTEMPTS = 30;
+/**
+ * How long the launch window stays open after the trust Enter when the wait
+ * runs out first (review of #3776): gemini takes about 2 s to draw its restart
+ * line, and until then the answered dialog still reads as `press` — a poller
+ * free to answer it would type `1` into the restarted gemini.
+ */
+const GEMINI_TRUST_SETTLE_MS = 5000;
 /** Timeout for waiting for prompt before sending a message */
 const GEMINI_PROMPT_WAIT_TIMEOUT_MS = 15000;
 /**
@@ -93,12 +102,20 @@ class GeminiTool extends base_1.BaseCLITool {
                 executablePath: this.command,
                 worktreePath,
             });
-            await (0, tmux_1.sendKeys)(sessionName, (0, launch_screen_1.withLaunchScreenCleared)(launchCommand), true);
-            // Wait for Gemini to initialize (minimum wait for banner/auth)
-            await new Promise((resolve) => setTimeout(resolve, GEMINI_INIT_WAIT_MS));
-            // Poll until Gemini interactive prompt is ready
-            // Handles trust dialog automatically if encountered
-            await this.waitForReady(sessionName);
+            // Issue #3776: from the launch line to the end of `waitForReady`, the
+            // trust dialog is this launch's to answer; the Auto-Yes poller leaves it.
+            (0, launch_window_1.beginLaunchWindow)(sessionName);
+            try {
+                await (0, tmux_1.sendKeys)(sessionName, (0, launch_screen_1.withLaunchScreenCleared)(launchCommand), true);
+                // Wait for Gemini to initialize (minimum wait for banner/auth)
+                await new Promise((resolve) => setTimeout(resolve, GEMINI_INIT_WAIT_MS));
+                // Poll until Gemini interactive prompt is ready
+                // Handles trust dialog automatically if encountered
+                await this.waitForReady(sessionName);
+            }
+            finally {
+                (0, launch_window_1.endLaunchWindow)(sessionName);
+            }
             logger.info('started-gemini-session');
         }
         catch (error) {
@@ -110,9 +127,16 @@ class GeminiTool extends base_1.BaseCLITool {
      * Wait for Gemini CLI to become ready (prompt visible).
      * Handles trust dialog automatically if encountered.
      * Polls until GEMINI_PROMPT_PATTERN is detected or max attempts reached.
+     *
+     * Issue #3776: the trust dialog gets its Enter only while the cursor is on
+     * `1. Trust folder` ({@link GEMINI_TRUST_LAUNCH_DIALOG}); on any other row,
+     * or on a screen that looks like the dialog but no longer reads as it, nothing
+     * is sent and the launch logs why, once per reason.
      */
     async waitForReady(sessionName) {
         let trustDialogHandled = false;
+        let trustPressedAt = null;
+        const loggedDecisions = new Set();
         for (let i = 0; i < GEMINI_INIT_MAX_ATTEMPTS; i++) {
             try {
                 const rawOutput = await (0, tmux_1.capturePane)(sessionName, capture_spec_1.GEMINI_PANE_HEIGHT);
@@ -125,18 +149,40 @@ class GeminiTool extends base_1.BaseCLITool {
                     return;
                 }
                 // Handle trust dialog if not yet handled
-                if (!trustDialogHandled && output.includes('Do you trust this folder?')) {
-                    await (0, tmux_1.sendSpecialKey)(sessionName, 'Enter');
-                    trustDialogHandled = true;
-                    logger.info('auto-trusted-folder-for-gemini');
-                    // Continue polling for prompt after trust dialog
+                if (!trustDialogHandled) {
+                    const decision = (0, launch_dialog_1.decideLaunchDialog)(launch_dialog_1.GEMINI_TRUST_LAUNCH_DIALOG, output);
+                    if (decision.action === 'press') {
+                        await (0, tmux_1.sendSpecialKey)(sessionName, decision.key);
+                        trustDialogHandled = true;
+                        trustPressedAt = Date.now();
+                        // Issue #3790: the poller leaves the answered dialog alone even if
+                        // the window closes before gemini redraws it.
+                        (0, launch_window_1.recordLaunchDialogPress)(sessionName, trustPressedAt);
+                        logger.info('auto-trusted-folder-for-gemini');
+                        // Continue polling for prompt after trust dialog
+                    }
+                    else {
+                        const warning = (0, launch_dialog_1.launchDialogWarning)(launch_dialog_1.GEMINI_TRUST_LAUNCH_DIALOG, decision);
+                        if (warning && decision.action !== 'absent' && !loggedDecisions.has(decision.reason)) {
+                            loggedDecisions.add(decision.reason);
+                            logger.warn(warning.event, { sessionName, ...warning.fields });
+                        }
+                    }
                 }
             }
-            catch {
+            catch (error) {
                 // Capture may fail during initialization - continue polling
+                logger.debug('gemini-ready-capture-failed', { sessionName, error: (0, errors_1.getErrorMessage)(error) });
             }
             await new Promise((resolve) => setTimeout(resolve, GEMINI_POLL_INTERVAL_MS));
         }
+        // The caller closes the launch window when this returns: not before the
+        // trust Enter has had time to show gemini's restart line.
+        if (trustPressedAt !== null) {
+            const settle = GEMINI_TRUST_SETTLE_MS - (Date.now() - trustPressedAt);
+            if (settle > 0)
+                await new Promise((resolve) => setTimeout(resolve, settle));
+        }
         logger.info('gemini-prompt-detection');
     }
     /**
@@ -154,8 +200,9 @@ class GeminiTool extends base_1.BaseCLITool {
                     return;
                 }
             }
-            catch {
+            catch (error) {
                 // Capture may fail - continue polling
+                logger.debug('gemini-prompt-capture-failed', { sessionName, error: (0, errors_1.getErrorMessage)(error) });
             }
             await new Promise((resolve) => setTimeout(resolve, pollInterval));
         }