commandmate 0.44.1 → 0.44.3

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

@@ -44,6 +44,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.AUTO_YES_ENTER_FALLBACK_ANSWER = void 0;
 exports.getActivePollerCount = getActivePollerCount;
 exports.clearAllPollerStates = clearAllPollerStates;
 exports.getLastServerResponseTimestamp = getLastServerResponseTimestamp;
@@ -65,13 +66,17 @@ const antigravity_permission_receipts_1 = require("./polling/antigravity-permiss
 const auto_yes_resolver_1 = require("./polling/auto-yes-resolver");
 const auto_yes_policy_1 = require("./polling/auto-yes-policy");
 const detect_1 = require("./detection/tools/codex/detect");
+const frame_1 = require("./detection/tools/frame");
 const auto_yes_suppression_state_1 = require("./polling/auto-yes-suppression-state");
 const auto_yes_dialog_gate_1 = require("./polling/auto-yes-dialog-gate");
+const auto_yes_enter_fallback_1 = require("./polling/auto-yes-enter-fallback");
 const task_transition_service_1 = require("./tasks/task-transition-service");
 const db_instance_1 = require("./db/db-instance");
 const chat_db_1 = require("./db/chat-db");
 const worktree_session_ownership_1 = require("./cli-tools/worktree-session-ownership");
 const prompt_answer_sender_1 = require("./prompt-answer-sender");
+const prompt_answer_semantic_1 = require("./prompt-answer-semantic");
+const tmux_1 = require("./tmux/tmux");
 const manager_1 = require("./cli-tools/manager");
 const cli_patterns_1 = require("./detection/cli-patterns");
 const prompt_key_1 = require("./detection/prompt-key");
@@ -82,17 +87,16 @@ const logger_1 = require("../lib/logger");
 const logger = (0, logger_1.createLogger)('auto-yes-poller');
 const path_validator_1 = require("./security/path-validator");
 const auto_yes_state_1 = require("./auto-yes-state");
+const global_state_1 = require("./global-state");
 /** In-memory storage for poller states (globalThis for hot reload persistence) */
-const autoYesPollerStates = globalThis.__autoYesPollerStates ??
-    (globalThis.__autoYesPollerStates = new Map());
+const autoYesPollerStates = (0, global_state_1.getOrInitGlobal)('__autoYesPollerStates', () => new Map());
 /**
  * When `antigravity-autoyes-withheld-no-hook-receipt` was last logged, per
  * compositeKey (Issue #2857). The poller re-reads a static pane every 2s, so the
  * line is limited to one per {@link WITHHELD_NO_RECEIPT_LOG_INTERVAL_MS} per
  * instance. globalThis for the same reason as the poller states above.
  */
-const withheldNoReceiptLoggedAt = globalThis.__autoYesWithheldNoReceiptLoggedAt ??
-    (globalThis.__autoYesWithheldNoReceiptLoggedAt = new Map());
+const withheldNoReceiptLoggedAt = (0, global_state_1.getOrInitGlobal)('__autoYesWithheldNoReceiptLoggedAt', () => new Map());
 /** Least gap between two `antigravity-autoyes-withheld-no-hook-receipt` lines for one instance. */
 const WITHHELD_NO_RECEIPT_LOG_INTERVAL_MS = 60_000;
 // =============================================================================
@@ -160,6 +164,8 @@ function updateLastServerResponseTimestamp(compositeKey, timestamp) {
 }
 /**
  * Reset error count for a poller and restore the default polling interval.
+ * Called after every poll that ran to the end without an error (Issue #3329)
+ * and after an answer is sent.
  *
  * @param compositeKey - Composite key
  */
@@ -182,6 +188,14 @@ function incrementErrorCount(compositeKey) {
         pollerState.consecutiveErrors++;
         pollerState.currentInterval = (0, auto_yes_state_1.calculateBackoffInterval)(pollerState.consecutiveErrors);
         // Issue #499 Item 5: Auto-stop after consecutive error threshold.
+        //
+        // Issue #3184: this is the `consecutive-errors` row of AUTO_YES_LIFECYCLE
+        // (`lib/auto-yes-lifecycle`) — disable with `consecutive_errors`, stop the
+        // poller — applied here directly rather than through `releaseAutoYes`:
+        // that module reaches this one through the auto-yes-manager barrel, so
+        // importing it back would be a cycle. `auto-yes-lifecycle-3184.test.ts`
+        // holds this call and the table row equal. A missing session never gets
+        // here (Issue #3329): `pollAutoYes` waits for it instead of counting it.
         if (pollerState.consecutiveErrors >= auto_yes_config_1.AUTO_STOP_ERROR_THRESHOLD) {
             const worktreeId = (0, auto_yes_state_1.extractWorktreeId)(compositeKey);
             const cliToolId = (0, auto_yes_state_1.extractCliToolId)(compositeKey);
@@ -381,6 +395,366 @@ function logIfWithheldForWantOfReceipt(worktreeId, instanceId, compositeKey, rea
         hint: 'hook の受信記録が直近に無いため Auto-Yes は答えなかった。~/.gemini/config/hooks.json の向き先（#2622）を確認',
     });
 }
+/**
+ * Issue #3214: the form the four suppression exits of `detectAndRespondToPrompt`
+ * share. Records why Auto-Yes left the prompt alone (`recordPolicySuppression`,
+ * not throttled), then prints the WARN once per frame (`warnOncePerFrame`).
+ *
+ * @param suppression - Handed to `recordPolicySuppression` as is
+ * @param warnFrameKey - Handed to `warnOncePerFrame` as is: the prompt's
+ *   `frameKey` plus the exit's own detail
+ * @param event - The WARN's log name
+ * @param detail - The WARN's fields after `worktreeId`, `cliToolId` and `instanceId`
+ */
+function suppressAndWarnOnce(prompt, suppression, warnFrameKey, event, detail) {
+    const { worktreeId, cliToolId, instanceId } = prompt;
+    (0, auto_yes_suppression_state_1.recordPolicySuppression)(worktreeId, cliToolId, instanceId, suppression);
+    warnOncePerFrame(prompt.pollerState, warnFrameKey, event, {
+        worktreeId,
+        cliToolId,
+        instanceId,
+        ...detail,
+    });
+}
+/**
+ * Issue #3214: steps 3, 3.2 and 3.5 of `detectAndRespondToPrompt` -- the frames
+ * that read as a prompt and are still not Auto-Yes's to answer, judged in the
+ * order they always were. "The detection above" in the comments below is that
+ * function's step 1.
+ *
+ * Issue #3397: step 3.5 no longer records its refusal here. It hands the gate's
+ * verdict back so `tryEnterFallback` can look at the frame first, and records
+ * through {@link suppressUnclassifiedFrame} when that sends nothing. Steps 3 and
+ * 3.2 still win: an Enter never reaches codex's launch dialogs or its `/model`
+ * picker.
+ *
+ * @param frame - The tick's one normalised frame (Issue #3183)
+ */
+function suppressIfNotOursToAnswer(prompt, frame) {
+    const { cliToolId, promptData, frameKey } = prompt;
+    // 3. Issue #1829: codex's own launch dialogs are CodexTool.waitForReady()'s
+    // to answer, not the poller's. Every one of them defaults to option 1, and
+    // the base rules answer the default:
+    //
+    //   "Hooks need review"  -> 1. Review hooks   (undoes Issue #1760; the pane
+    //                           then sits two screens deep in a review UI that
+    //                           only `t`/`esc` leave, reported as `running`)
+    //   "Update available"   -> 1. Update now     (undoes Issue #890; runs
+    //                           `npm install -g @openai/codex`, killing codex)
+    //   "Do you trust …"     -> 1. Yes, continue
+    //
+    // waitForReady answers the same screens deliberately and differently ('3',
+    // '2', '1' — each without a trailing Enter), but only during startSession,
+    // while this poller runs on its own 2s phase for the life of the session.
+    // Whichever sees the dialog first decides, so the fix is to leave them all
+    // to the tool. Auto-answer layer only: the detection above still reports the
+    // prompt, so the human keeps seeing the screen and the response poller
+    // still notifies them about it.
+    const launchDialog = cliToolId === 'codex' ? (0, cli_patterns_1.getCodexLifecycleDialog)(frame) : null;
+    if (launchDialog) {
+        // Recorded through the #1684 channel so `capture --json` and `cmate wait`
+        // can name the reason instead of showing a worker that went quiet.
+        suppressAndWarnOnce(prompt, { reason: 'agent-launch-dialog', mode: null, promptType: promptData.type }, `${frameKey}\u0000${launchDialog}`, 'poller:auto-yes-skipped-launch-dialog', { dialog: launchDialog, promptType: promptData.type });
+        return { kind: 'left-alone' };
+    }
+    // 3.2. Issue #3062: codex's `/model` picker (both stages) is not ours to
+    // answer. A digit there is an immediate decision, so the base rules'
+    // default would choose the model and effort for the operator. Judged by the
+    // picker's own footer, not by `kind: picker`, which the hooks screens share.
+    // The tool's `detectPrompt` still reports the prompt, so `/prompt-response`
+    // (the human's answer) is unaffected. Reuses `unclassified-frame`: the tool
+    // recognised the frame and deliberately declined it.
+    if (cliToolId === 'codex' && (0, detect_1.isCodexModelPickerFrame)(frame)) {
+        suppressAndWarnOnce(prompt, { reason: 'unclassified-frame', mode: null, promptType: promptData.type }, `${frameKey}\u0000codex-model-picker`, 'poller:auto-yes-skipped-model-picker', { promptType: promptData.type });
+        return { kind: 'left-alone' };
+    }
+    // 3.5. Issue #1928 (§4 D1 decision 4): the generic numbered-list inference is
+    // not enough to send an answer. The detection above judges the ROWS, and the
+    // rows of an agent's own reply can be indistinguishable from a dialog's --
+    // opencode 1.18 answering "list three options and ask which one" is the
+    // reported case (#1896), and the `1` this poller sent in reply was not
+    // answering anything, it was SENT AS A USER UTTERANCE. What separates the two
+    // is position and chrome, which only the tool's own module knows, so the
+    // decision is delegated to `detectDialog` (the seam #1927 declared).
+    //
+    // Per tool, and only for tools whose dialogs were measured from their own
+    // live captures -- see AUTO_YES_DIALOG_GATE_DEFAULT_MODE. An ungated tool
+    // reaches `allowed: true` without being judged, which is the pre-#1928
+    // behaviour and the right one where nobody has measured anything.
+    //
+    // Recorded through the #1684 channel with the reason code #1924 landed for
+    // exactly this position, so `capture --json` and `cmate wait` can name the
+    // gap instead of showing a worker that silently went quiet.
+    const dialogGate = (0, auto_yes_dialog_gate_1.evaluateAutoYesDialogGate)(cliToolId, promptData.type, frame);
+    if (!dialogGate.allowed) {
+        return { kind: 'dialog-gate-refused', dialogGate };
+    }
+    return { kind: 'ours' };
+}
+/**
+ * Step 3.5's record: the tool's dialog detector did not vouch for the frame and
+ * nothing was sent (Issue #1928). Split out of `suppressIfNotOursToAnswer` by
+ * Issue #3397, unchanged, so it runs after `tryEnterFallback` declined.
+ */
+function suppressUnclassifiedFrame(prompt, dialogGate) {
+    const { promptData, frameKey } = prompt;
+    suppressAndWarnOnce(prompt, { reason: 'unclassified-frame', mode: null, promptType: promptData.type }, `${frameKey}\u0000${dialogGate.dialog?.kind ?? ''}\u0000${dialogGate.mode}`, 'poller:auto-yes-skipped-unclassified-frame', {
+        promptType: promptData.type,
+        dialogKind: dialogGate.dialog?.kind ?? null,
+        answerMode: dialogGate.dialog?.answerMode ?? null,
+        gateMode: dialogGate.mode,
+    });
+}
+/**
+ * The audit row's `answer` for the Enter (Issue #3397): not a digit, so the
+ * History reads as "Auto-Yes pressed Enter" rather than as a chosen option.
+ */
+exports.AUTO_YES_ENTER_FALLBACK_ANSWER = '[Enter]';
+/**
+ * Issue #3397: is the fresh capture still the screen the Enter was decided for?
+ * Re-reads it the way one tick does — prompt reading, the same `promptFrameKey`,
+ * codex's launch dialogs and `/model` picker, the dialog gate refusing with no
+ * dialog vouched for, and `judgeEnterFallback` (input box off screen, tool
+ * alive, not thinking). The policy and the checkbox rule read `promptData`,
+ * which the equal `promptFrameKey` already pins (type, question, options).
+ */
+function isStillEnterFallbackScreen(prompt, fresh) {
+    const { worktreeId, cliToolId, instanceId, frameKey } = prompt;
+    const clean = (0, cli_patterns_1.stripBoxDrawing)((0, cli_patterns_1.stripAnsi)(fresh));
+    const frame = (0, frame_1.normalizeFrame)(fresh, cliToolId);
+    const detection = (0, response_checker_1.detectPromptOnCleanFrame)(clean, cliToolId, clean.split('\n'), fresh, { worktreeId, instanceId }, frame);
+    if (!detection.isPrompt || !detection.promptData)
+        return false;
+    if (promptFrameKey(detection.promptData) !== frameKey)
+        return false;
+    if (cliToolId === 'codex' && ((0, cli_patterns_1.getCodexLifecycleDialog)(frame) || (0, detect_1.isCodexModelPickerFrame)(frame))) {
+        return false;
+    }
+    const gate = (0, auto_yes_dialog_gate_1.evaluateAutoYesDialogGate)(cliToolId, detection.promptData.type, frame);
+    if (gate.allowed || gate.dialog !== null)
+        return false;
+    return (0, auto_yes_enter_fallback_1.judgeEnterFallback)(cliToolId, fresh).eligible;
+}
+/**
+ * Issue #3397: a frame the dialog gate refused may still be a choice screen
+ * CommandMate cannot read — the one the prompt window offers direct input for.
+ * Send ONE Enter there (confirm whatever is selected), under every condition
+ * `judgeEnterFallback` and this function check; otherwise record the refusal as
+ * step 3.5 always did.
+ *
+ * Order, each one able to stop the Enter:
+ *  1. `judgeEnterFallback` (rollout table, refusal, composer off screen, tool
+ *     alive, not thinking) — and the gate must not have vouched for a dialog it
+ *     refused to type into (opencode's `keys` strip, #1893);
+ *  2. the screen already had its Enter: record `no-effect`, send nothing;
+ *  3. the contract policy, exactly as step 4 applies it (mode, allow-listed
+ *     types, deny patterns over the question, options and `approvalTarget`);
+ *     a prompt the base rules would not answer (multi-select, typed text) gets
+ *     nothing either;
+ *  4. the screen must have been eligible on the previous tick as well;
+ *  5. the session must be this server's (#2865);
+ *  6. a capture taken now, past the capture cache, must still be that screen
+ *     ({@link isStillEnterFallbackScreen}).
+ *
+ * @returns true when the Enter was sent; the caller returns `responded`
+ */
+async function tryEnterFallback(prompt, promptDetection, dialogGate, rawOutput) {
+    const { worktreeId, cliToolId, instanceId, pollerState, promptData, frameKey } = prompt;
+    const judgement = dialogGate.dialog === null ? (0, auto_yes_enter_fallback_1.judgeEnterFallback)(cliToolId, rawOutput) : null;
+    if (judgement === null || !judgement.eligible) {
+        pollerState.enterFallbackCandidateKey = null;
+        suppressUnclassifiedFrame(prompt, dialogGate);
+        return false;
+    }
+    const screenKey = (0, auto_yes_enter_fallback_1.enterFallbackScreenKey)(promptData);
+    // 2. The Enter did not move the screen on. Another one would be a guess.
+    if (pollerState.enterFallbackSentKey === frameKey) {
+        pollerState.enterFallbackCandidateKey = null;
+        (0, auto_yes_enter_fallback_1.recordEnterFallbackNoEffect)(worktreeId, cliToolId, instanceId, screenKey);
+        suppressUnclassifiedFrame(prompt, dialogGate);
+        warnOncePerFrame(pollerState, `${frameKey}\u0000enter-fallback-no-effect`, 'poller:auto-yes-enter-fallback-no-effect', {
+            worktreeId,
+            cliToolId,
+            instanceId,
+            promptType: promptData.type,
+            refusalReason: judgement.refusalReason,
+        });
+        return false;
+    }
+    // 3. The contract policy, as step 4 reads it.
+    const policy = (0, auto_yes_policy_1.getSessionAutoYesPolicy)(worktreeId, cliToolId, instanceId);
+    const resolution = (0, auto_yes_resolver_1.resolveAutoAnswerWithPolicy)(promptData, policy);
+    if (resolution.suppressedBy) {
+        pollerState.enterFallbackCandidateKey = null;
+        suppressAndWarnOnce(prompt, {
+            reason: resolution.suppressedBy,
+            mode: policy?.mode ?? null,
+            promptType: promptData.type,
+            pattern: resolution.pattern,
+        }, `${frameKey}\u0000${resolution.suppressedBy}\u0000${policy?.mode ?? ''}\u0000${resolution.pattern ?? ''}`, 'poller:auto-yes-suppressed-by-policy', {
+            reason: resolution.suppressedBy,
+            mode: policy?.mode ?? null,
+            pattern: resolution.pattern,
+            promptType: promptData.type,
+            enterFallback: true,
+        });
+        return false;
+    }
+    // A checkbox list is out of scope whatever the parser's flag says: the
+    // labels' boxes (`[ ]` / `[x]` / `[X]` / `[✔]`, the one reading in
+    // `prompt-answer-semantic` the sender shares) count too, so an Enter never
+    // submits a half-ticked list (Issue #3397; the base rules' #2755 reading
+    // covers `multiSelect` only).
+    if (resolution.answer === null ||
+        (promptData.type === 'multiple_choice' && (0, prompt_answer_semantic_1.isMultiSelectPrompt)(promptData))) {
+        pollerState.enterFallbackCandidateKey = null;
+        suppressUnclassifiedFrame(prompt, dialogGate);
+        return false;
+    }
+    // 4. Seen once: wait for the next tick to see the same screen again.
+    // Nothing is recorded as withheld here: Auto-Yes is about to answer, and a
+    // fresh `lastSuppression` would make `cmate wait` report the prompt to a
+    // human at once instead of holding for Auto-Yes (#2463).
+    if (pollerState.enterFallbackCandidateKey !== frameKey) {
+        pollerState.enterFallbackCandidateKey = frameKey;
+        logger.debug('poller:auto-yes-enter-fallback-candidate', {
+            worktreeId,
+            cliToolId,
+            instanceId,
+            promptType: promptData.type,
+        });
+        return false;
+    }
+    // 5. Never another server's session (Issue #2865).
+    const sessionName = manager_1.CLIToolManager.getInstance().getTool(cliToolId).getSessionName(worktreeId, instanceId);
+    const ownership = await (0, worktree_session_ownership_1.checkWorktreeSessionOwnership)(worktreeId, sessionName);
+    if (ownership === null || ownership.verdict === 'foreign') {
+        warnOncePerFrame(pollerState, `${frameKey}\u0000${sessionName}\u0000${ownership ? 'foreign' : 'worktree_not_found'}`, 'poller:auto-yes-skipped-foreign-session', {
+            worktreeId,
+            cliToolId,
+            instanceId,
+            sessionName,
+            sessionPath: ownership?.sessionPath ?? null,
+            reason: ownership ? 'foreign' : 'worktree_not_found',
+            enterFallback: true,
+        });
+        return false;
+    }
+    // 6. The last look before the key, at a capture taken NOW. The two ticks of
+    // step 4 read through the capture cache, whose TTL is longer than the poll
+    // interval, so "seen twice" can be one stale frame read twice: a redraw caught
+    // with its input box missing (#2457's repaint) while the real pane already
+    // has the box back. Everything that decided the Enter is judged again on the
+    // fresh frame; any difference sends nothing, and the next tick starts over.
+    const fresh = await (0, cli_session_1.captureSessionOutputFresh)(worktreeId, cliToolId, (rawOutput ?? '').split('\n').length, instanceId);
+    if (!isStillEnterFallbackScreen(prompt, fresh)) {
+        pollerState.enterFallbackCandidateKey = null;
+        logger.debug('poller:auto-yes-enter-fallback-fresh-frame-differs', {
+            worktreeId,
+            cliToolId,
+            instanceId,
+            promptType: promptData.type,
+        });
+        return false;
+    }
+    try {
+        await (0, tmux_1.sendSpecialKeys)(sessionName, ['Enter']);
+    }
+    finally {
+        (0, tmux_capture_cache_1.invalidateCache)(sessionName);
+    }
+    pollerState.enterFallbackSentKey = frameKey;
+    pollerState.enterFallbackCandidateKey = null;
+    (0, auto_yes_enter_fallback_1.recordEnterFallbackSent)(worktreeId, cliToolId, instanceId, {
+        promptType: promptData.type,
+        refusalReason: judgement.refusalReason,
+        screenKey,
+    });
+    logger.info('poller:auto-yes-enter-fallback-sent', {
+        worktreeId,
+        cliToolId,
+        instanceId,
+        promptType: promptData.type,
+        refusalReason: judgement.refusalReason,
+        composerState: judgement.composerState,
+    });
+    await finishAnsweredPrompt(prompt, promptDetection, exports.AUTO_YES_ENTER_FALLBACK_ANSWER);
+    return true;
+}
+/**
+ * Issue #3214: steps 6 and 7 of `detectAndRespondToPrompt` and everything after
+ * them -- what is done once the answer has reached tmux, in the order it always
+ * ran. Awaited inside that function's `try`, so a throw here still ends the
+ * tick as `error`.
+ *
+ * @param promptDetection - The detection `prompt.promptData` was read from; its
+ *   content becomes the audit row's
+ * @param answer - The answer that was sent
+ */
+async function finishAnsweredPrompt(prompt, promptDetection, answer) {
+    const { worktreeId, cliToolId, instanceId, compositeKey, pollerState, promptData, promptKey } = prompt;
+    // 6. Update timestamp and reset error count
+    updateLastServerResponseTimestamp(compositeKey, Date.now());
+    resetErrorCount(compositeKey);
+    // 7. Record answered prompt key and timestamp
+    pollerState.lastAnsweredPromptKey = promptKey;
+    pollerState.lastAnsweredAt = Date.now();
+    pollerState.lastSkipWarnKey = null;
+    logger.info('poller:response-sent', { worktreeId, cliToolId, instanceId });
+    // Issue #1548: the prompt was answered without a human. Raised only after
+    // the keys actually reached tmux, so a send that threw is not logged as an
+    // answer. No-ops when this instance is not running a contract.
+    (0, task_transition_service_1.applyEventToActiveTask)((0, db_instance_1.getDbInstance)(), worktreeId, cliToolId, 
+    // Undefined means the primary instance, which the task lookup identifies
+    // by the tool id itself (see getActiveTaskForInstance).
+    instanceId ?? cliToolId, 'prompt_answered_auto', { promptType: promptData.type });
+    // Issue #1685: persist question/options/answer to chat history so the audit
+    // trail survives even when the answer landed inside the response poller's
+    // interval and the prompt was never saved as a pending message. Must never
+    // fail the answer that already reached tmux.
+    let auditRecord = null;
+    try {
+        auditRecord = (0, chat_db_1.recordAnsweredPrompt)((0, db_instance_1.getDbInstance)(), {
+            worktreeId,
+            cliToolId,
+            instanceId: instanceId ?? cliToolId,
+            promptData,
+            answer,
+            answeredBy: 'auto',
+            content: promptDetection.rawContent || promptDetection.cleanContent,
+        });
+    }
+    catch (recordError) {
+        logger.warn('poller:prompt-audit-record-failed', {
+            worktreeId,
+            cliToolId,
+            instanceId,
+            error: (0, errors_1.getErrorMessage)(recordError),
+        });
+    }
+    if (auditRecord) {
+        const record = auditRecord;
+        // Fire-and-forget on purpose: the WS push is advisory, and awaiting a
+        // cold ws-server module load inside the poll path would make its
+        // completion timing nondeterministic for a side effect it doesn't
+        // depend on (the audit row is already committed above).
+        void Promise.resolve().then(() => __importStar(require('../lib/ws-server'))).then(({ broadcastMessage }) => {
+            broadcastMessage(record.created ? 'message' : 'message_updated', {
+                worktreeId,
+                message: record.message,
+            });
+        })
+            .catch(() => { });
+    }
+    // Dynamic imports avoid a module cycle through terminal-broadcast ->
+    // current-output-builder -> auto-yes-manager -> this poller.
+    const [{ startPolling: startResponsePolling }, { broadcastTerminalSnapshotAfterInteraction }] = await Promise.all([
+        Promise.resolve().then(() => __importStar(require('../lib/polling/response-poller'))),
+        Promise.resolve().then(() => __importStar(require('../lib/realtime/terminal-broadcast'))),
+    ]);
+    startResponsePolling(worktreeId, cliToolId, instanceId);
+    void broadcastTerminalSnapshotAfterInteraction(worktreeId, cliToolId, instanceId);
+}
 /**
  * Detect prompt in terminal output, resolve auto-answer, and send response.
  *
@@ -438,12 +812,28 @@ async function detectAndRespondToPrompt(worktreeId, pollerState, cliToolId, clea
         // machine whose hook does not reach us. The price is that Auto-Yes leaves
         // such a machine's dialogs alone, which is why `logIfWithheldForWantOfReceipt`
         // says so.
+        // Issue #3397: a session begun since the last tick (a relaunch the poller
+        // outlived) starts with no screen that had its Enter.
+        const epoch = (0, auto_yes_enter_fallback_1.getEnterFallbackSessionEpoch)(compositeKey);
+        if ((pollerState.enterFallbackEpoch ?? 0) !== epoch) {
+            pollerState.enterFallbackSentKey = null;
+            pollerState.enterFallbackCandidateKey = null;
+            pollerState.enterFallbackEpoch = epoch;
+        }
         const receiptScope = { worktreeId, instanceId };
-        const promptDetection = (0, response_checker_1.detectPromptOnCleanFrame)(cleanOutput, cliToolId, precomputedLines, rawOutput, receiptScope);
+        // Issue #3183: the ONE frame every judgement below reads — normalised once,
+        // from the capture as captured (the input-box markers are rule rows the
+        // cleaned spelling has blanked), and handed as the same object to the
+        // prompt reading, the codex launch guards and the dialog gate. That is what
+        // makes "the status chain and Auto-Yes read the same live region" a fact
+        // rather than a hope: there is no second normalisation to disagree with.
+        const frame = (0, frame_1.normalizeFrame)(rawOutput ?? cleanOutput, cliToolId);
+        const promptDetection = (0, response_checker_1.detectPromptOnCleanFrame)(cleanOutput, cliToolId, precomputedLines, rawOutput, receiptScope, frame);
         if (!promptDetection.isPrompt || !promptDetection.promptData) {
             pollerState.lastAnsweredPromptKey = null;
             pollerState.lastAnsweredAt = null;
             pollerState.lastSkipWarnKey = null;
+            pollerState.enterFallbackCandidateKey = null;
             if (cliToolId === 'antigravity' && !promptDetection.isPrompt) {
                 logIfWithheldForWantOfReceipt(worktreeId, instanceId, compositeKey, () => (0, response_checker_1.detectPromptOnCleanFrame)(cleanOutput, cliToolId, precomputedLines, rawOutput));
             }
@@ -455,97 +845,31 @@ async function detectAndRespondToPrompt(worktreeId, pollerState, cliToolId, clea
         if (isDuplicatePrompt(pollerState, promptKey)) {
             return 'duplicate';
         }
-        // 3. Issue #1829: codex's own launch dialogs are CodexTool.waitForReady()'s
-        // to answer, not the poller's. Every one of them defaults to option 1, and
-        // the base rules answer the default:
-        //
-        //   "Hooks need review"  -> 1. Review hooks   (undoes Issue #1760; the pane
-        //                           then sits two screens deep in a review UI that
-        //                           only `t`/`esc` leave, reported as `running`)
-        //   "Update available"   -> 1. Update now     (undoes Issue #890; runs
-        //                           `npm install -g @openai/codex`, killing codex)
-        //   "Do you trust …"     -> 1. Yes, continue
-        //
-        // waitForReady answers the same screens deliberately and differently ('3',
-        // '2', '1' — each without a trailing Enter), but only during startSession,
-        // while this poller runs on its own 2s phase for the life of the session.
-        // Whichever sees the dialog first decides, so the fix is to leave them all
-        // to the tool. Auto-answer layer only: the detection above still reports the
-        // prompt, so the human keeps seeing the screen and the response poller
-        // still notifies them about it.
-        const launchDialog = cliToolId === 'codex' ? (0, cli_patterns_1.getCodexLifecycleDialog)(cleanOutput) : null;
-        if (launchDialog) {
-            // Recorded through the #1684 channel so `capture --json` and `cmate wait`
-            // can name the reason instead of showing a worker that went quiet.
-            (0, auto_yes_suppression_state_1.recordPolicySuppression)(worktreeId, cliToolId, instanceId, {
-                reason: 'agent-launch-dialog',
-                mode: null,
-                promptType: promptDetection.promptData.type,
-            });
-            warnOncePerFrame(pollerState, `${frameKey}\u0000${launchDialog}`, 'poller:auto-yes-skipped-launch-dialog', {
-                worktreeId,
-                cliToolId,
-                instanceId,
-                dialog: launchDialog,
-                promptType: promptDetection.promptData.type,
-            });
-            return 'no_answer';
+        const judged = {
+            worktreeId,
+            cliToolId,
+            instanceId,
+            compositeKey,
+            pollerState,
+            promptData: promptDetection.promptData,
+            promptKey,
+            frameKey,
+        };
+        // 3., 3.2., 3.5. Frames that are not Auto-Yes's to answer: see
+        // `suppressIfNotOursToAnswer`.
+        const notOurs = suppressIfNotOursToAnswer(judged, frame);
+        if (notOurs.kind !== 'dialog-gate-refused') {
+            pollerState.enterFallbackCandidateKey = null;
         }
-        // 3.2. Issue #3062: codex's `/model` picker (both stages) is not ours to
-        // answer. A digit there is an immediate decision, so the base rules'
-        // default would choose the model and effort for the operator. Judged by the
-        // picker's own footer, not by `kind: picker`, which the hooks screens share.
-        // The tool's `detectPrompt` still reports the prompt, so `/prompt-response`
-        // (the human's answer) is unaffected. Reuses `unclassified-frame`: the tool
-        // recognised the frame and deliberately declined it.
-        if (cliToolId === 'codex' && (0, detect_1.isCodexModelPickerFrame)(cleanOutput)) {
-            (0, auto_yes_suppression_state_1.recordPolicySuppression)(worktreeId, cliToolId, instanceId, {
-                reason: 'unclassified-frame',
-                mode: null,
-                promptType: promptDetection.promptData.type,
-            });
-            warnOncePerFrame(pollerState, `${frameKey}\u0000codex-model-picker`, 'poller:auto-yes-skipped-model-picker', {
-                worktreeId,
-                cliToolId,
-                instanceId,
-                promptType: promptDetection.promptData.type,
-            });
+        if (notOurs.kind === 'left-alone') {
             return 'no_answer';
         }
-        // 3.5. Issue #1928 (§4 D1 decision 4): the generic numbered-list inference is
-        // not enough to send an answer. The detection above judges the ROWS, and the
-        // rows of an agent's own reply can be indistinguishable from a dialog's --
-        // opencode 1.18 answering "list three options and ask which one" is the
-        // reported case (#1896), and the `1` this poller sent in reply was not
-        // answering anything, it was SENT AS A USER UTTERANCE. What separates the two
-        // is position and chrome, which only the tool's own module knows, so the
-        // decision is delegated to `detectDialog` (the seam #1927 declared).
-        //
-        // Per tool, and only for tools whose dialogs were measured from their own
-        // live captures -- see AUTO_YES_DIALOG_GATE_DEFAULT_MODE. An ungated tool
-        // reaches `allowed: true` without being judged, which is the pre-#1928
-        // behaviour and the right one where nobody has measured anything.
-        //
-        // Recorded through the #1684 channel with the reason code #1924 landed for
-        // exactly this position, so `capture --json` and `cmate wait` can name the
-        // gap instead of showing a worker that silently went quiet.
-        const dialogGate = (0, auto_yes_dialog_gate_1.evaluateAutoYesDialogGate)(cliToolId, promptDetection.promptData.type, cleanOutput);
-        if (!dialogGate.allowed) {
-            (0, auto_yes_suppression_state_1.recordPolicySuppression)(worktreeId, cliToolId, instanceId, {
-                reason: 'unclassified-frame',
-                mode: null,
-                promptType: promptDetection.promptData.type,
-            });
-            warnOncePerFrame(pollerState, `${frameKey}\u0000${dialogGate.dialog?.kind ?? ''}\u0000${dialogGate.mode}`, 'poller:auto-yes-skipped-unclassified-frame', {
-                worktreeId,
-                cliToolId,
-                instanceId,
-                promptType: promptDetection.promptData.type,
-                dialogKind: dialogGate.dialog?.kind ?? null,
-                answerMode: dialogGate.dialog?.answerMode ?? null,
-                gateMode: dialogGate.mode,
-            });
-            return 'no_answer';
+        // 3.6. Issue #3397: a refused frame may be a choice screen CommandMate
+        // cannot read; with Auto-Yes on it gets one Enter. See `tryEnterFallback`.
+        if (notOurs.kind === 'dialog-gate-refused') {
+            return (await tryEnterFallback(judged, promptDetection, notOurs.dialogGate, rawOutput))
+                ? 'responded'
+                : 'no_answer';
         }
         // 4. Resolve auto answer under the execution contract's policy (Issue #1547).
         // Auto-Yes reads the frame itself instead of going through status-detector
@@ -559,16 +883,12 @@ async function detectAndRespondToPrompt(worktreeId, pollerState, cliToolId, clea
             // Issue #1684: the log line alone leaves a CLI-driven pipeline blind to
             // why its worker stalled. Record the suppression so buildCurrentOutput
             // can publish it (`autoYes.lastSuppression` in capture --json).
-            (0, auto_yes_suppression_state_1.recordPolicySuppression)(worktreeId, cliToolId, instanceId, {
+            suppressAndWarnOnce(judged, {
                 reason: resolution.suppressedBy,
                 mode: policy?.mode ?? null,
                 promptType: promptDetection.promptData.type,
                 pattern: resolution.pattern,
-            });
-            warnOncePerFrame(pollerState, `${frameKey}\u0000${resolution.suppressedBy}\u0000${policy?.mode ?? ''}\u0000${resolution.pattern ?? ''}`, 'poller:auto-yes-suppressed-by-policy', {
-                worktreeId,
-                cliToolId,
-                instanceId,
+            }, `${frameKey}\u0000${resolution.suppressedBy}\u0000${policy?.mode ?? ''}\u0000${resolution.pattern ?? ''}`, 'poller:auto-yes-suppressed-by-policy', {
                 reason: resolution.suppressedBy,
                 mode: policy?.mode ?? null,
                 pattern: resolution.pattern,
@@ -608,67 +928,8 @@ async function detectAndRespondToPrompt(worktreeId, pollerState, cliToolId, clea
         finally {
             (0, tmux_capture_cache_1.invalidateCache)(sessionName);
         }
-        // 6. Update timestamp and reset error count
-        updateLastServerResponseTimestamp(compositeKey, Date.now());
-        resetErrorCount(compositeKey);
-        // 7. Record answered prompt key and timestamp
-        pollerState.lastAnsweredPromptKey = promptKey;
-        pollerState.lastAnsweredAt = Date.now();
-        pollerState.lastSkipWarnKey = null;
-        logger.info('poller:response-sent', { worktreeId, cliToolId, instanceId });
-        // Issue #1548: the prompt was answered without a human. Raised only after
-        // the keys actually reached tmux, so a send that threw is not logged as an
-        // answer. No-ops when this instance is not running a contract.
-        (0, task_transition_service_1.applyEventToActiveTask)((0, db_instance_1.getDbInstance)(), worktreeId, cliToolId, 
-        // Undefined means the primary instance, which the task lookup identifies
-        // by the tool id itself (see getActiveTaskForInstance).
-        instanceId ?? cliToolId, 'prompt_answered_auto', { promptType: promptDetection.promptData.type });
-        // Issue #1685: persist question/options/answer to chat history so the audit
-        // trail survives even when the answer landed inside the response poller's
-        // interval and the prompt was never saved as a pending message. Must never
-        // fail the answer that already reached tmux.
-        let auditRecord = null;
-        try {
-            auditRecord = (0, chat_db_1.recordAnsweredPrompt)((0, db_instance_1.getDbInstance)(), {
-                worktreeId,
-                cliToolId,
-                instanceId: instanceId ?? cliToolId,
-                promptData: promptDetection.promptData,
-                answer,
-                answeredBy: 'auto',
-                content: promptDetection.rawContent || promptDetection.cleanContent,
-            });
-        }
-        catch (recordError) {
-            logger.warn('poller:prompt-audit-record-failed', {
-                worktreeId,
-                cliToolId,
-                instanceId,
-                error: (0, errors_1.getErrorMessage)(recordError),
-            });
-        }
-        if (auditRecord) {
-            const record = auditRecord;
-            // Fire-and-forget on purpose: the WS push is advisory, and awaiting a
-            // cold ws-server module load inside the poll path would make its
-            // completion timing nondeterministic for a side effect it doesn't
-            // depend on (the audit row is already committed above).
-            void Promise.resolve().then(() => __importStar(require('../lib/ws-server'))).then(({ broadcastMessage }) => {
-                broadcastMessage(record.created ? 'message' : 'message_updated', {
-                    worktreeId,
-                    message: record.message,
-                });
-            })
-                .catch(() => { });
-        }
-        // Dynamic imports avoid a module cycle through terminal-broadcast ->
-        // current-output-builder -> auto-yes-manager -> this poller.
-        const [{ startPolling: startResponsePolling }, { broadcastTerminalSnapshotAfterInteraction }] = await Promise.all([
-            Promise.resolve().then(() => __importStar(require('../lib/polling/response-poller'))),
-            Promise.resolve().then(() => __importStar(require('../lib/realtime/terminal-broadcast'))),
-        ]);
-        startResponsePolling(worktreeId, cliToolId, instanceId);
-        void broadcastTerminalSnapshotAfterInteraction(worktreeId, cliToolId, instanceId);
+        // 6., 7. The answer reached tmux: see `finishAnsweredPrompt`.
+        await finishAnsweredPrompt(judged, promptDetection, answer);
         return 'responded';
     }
     catch {
@@ -703,6 +964,10 @@ async function pollAutoYes(worktreeId, cliToolId, instanceId) {
         // so a dialog anchored on box drawing is not invisible to the one path that
         // can answer it without a human.
         const { raw: rawOutput, clean: cleanOutput } = await capturePollerFrame(worktreeId, cliToolId, captureLines, instanceId);
+        if (pollerState.waitingForSession) {
+            pollerState.waitingForSession = false;
+            logger.info('poller:session-appeared', { worktreeId, cliToolId, instanceId });
+        }
         const lines = cleanOutput.split('\n');
         // 3. Stop condition delta check (Issue #314)
         if (processStopConditionDelta(compositeKey, pollerState, cleanOutput)) {
@@ -710,6 +975,13 @@ async function pollAutoYes(worktreeId, cliToolId, instanceId) {
         }
         // 4. Detect and respond to prompt
         const result = await detectAndRespondToPrompt(worktreeId, pollerState, cliToolId, cleanOutput, lines, instanceId, rawOutput);
+        // Issue #3329: a poll that ran to the end ends the run of errors, so only
+        // failures in a row reach AUTO_STOP_ERROR_THRESHOLD — not ones scattered
+        // over hours. Not on 'error': a capture that works followed by an answer
+        // that fails every time must still back off and stop.
+        if (result !== 'error') {
+            resetErrorCount(compositeKey);
+        }
         if (result === 'responded') {
             scheduleNextPoll(worktreeId, cliToolId, instanceId, auto_yes_state_1.COOLDOWN_INTERVAL_MS);
             return;
@@ -724,11 +996,37 @@ async function pollAutoYes(worktreeId, cliToolId, instanceId) {
         }
     }
     catch (error) {
+        // Issue #3329: no session is not an error. Auto-Yes lives independently of
+        // the session it answers for (`auto-yes-lifecycle`), and `send --auto-yes`
+        // enables it before the session starts — so wait until `expiresAt`, at the
+        // backoff cap, instead of counting toward `consecutive_errors`.
+        if (await isSessionMissing(worktreeId, cliToolId, instanceId)) {
+            if (!pollerState.waitingForSession) {
+                pollerState.waitingForSession = true;
+                logger.info('poller:waiting-for-session', { worktreeId, cliToolId, instanceId });
+            }
+            scheduleNextPoll(worktreeId, cliToolId, instanceId, auto_yes_state_1.MAX_BACKOFF_MS);
+            return;
+        }
         incrementErrorCount(compositeKey);
         logger.warn('poller:poll-error', { worktreeId, cliToolId, instanceId, error: (0, errors_1.getErrorMessage)(error) });
     }
     scheduleNextPoll(worktreeId, cliToolId, instanceId);
 }
+/**
+ * Whether a failed capture failed because the session does not exist
+ * (Issue #3329). Asked of tmux (`has-session`'s exit code), not read off the
+ * error text. `unknown` — tmux timed out or could not be run — is not "absent":
+ * the failure is counted as before, so a broken tmux still stops Auto-Yes.
+ */
+async function isSessionMissing(worktreeId, cliToolId, instanceId) {
+    try {
+        return (await (0, cli_session_1.getSessionPresence)(worktreeId, cliToolId, instanceId)) === 'absent';
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Schedule the next polling iteration
  *
@@ -820,6 +1118,10 @@ function startAutoYesPolling(worktreeId, cliToolId, instanceId) {
  * @param compositeKey - Composite key (worktreeId:cliToolId)
  */
 function stopAutoYesPolling(compositeKey) {
+    // Issue #3397: before the early return — the disable route and the session
+    // cleanup call this for an instance whose poller may already be gone, and the
+    // Enter record must not outlive the grant or the session either way.
+    (0, auto_yes_enter_fallback_1.forgetEnterFallback)(compositeKey);
     const pollerState = getPollerState(compositeKey);
     if (!pollerState)
         return;
@@ -842,6 +1144,7 @@ function stopAllAutoYesPolling() {
         logger.info('poller:stopped', { compositeKey: key, reason: 'shutdown' });
     }
     autoYesPollerStates.clear();
+    (0, auto_yes_enter_fallback_1.clearEnterFallbacks)();
 }
 /**
  * Get all composite keys that have active auto-yes poller entries.
@@ -865,6 +1168,8 @@ function getAutoYesPollerCompositeKeys() {
 function stopAutoYesPollingByWorktree(worktreeId) {
     const pollerKeys = (0, auto_yes_state_1.filterCompositeKeysByWorktree)(Array.from(autoYesPollerStates.keys()), worktreeId);
     pollerKeys.forEach(key => stopAutoYesPolling(key));
+    // Issue #3397: and the records of instances whose poller had already stopped.
+    (0, auto_yes_enter_fallback_1.forgetEnterFallbacksByWorktree)(worktreeId);
 }
 /**
  * Check if any auto-yes poller is active for a given worktreeId.