commandmate 0.46.0 → 0.47.0

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

@@ -8,8 +8,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.promptFrameKey = promptFrameKey;
 exports.warnOncePerFrame = warnOncePerFrame;
+exports.partialAnswerScreenKey = partialAnswerScreenKey;
+exports.getPartialAnswer = getPartialAnswer;
+exports.forgetPartialAnswer = forgetPartialAnswer;
+exports.forgetPartialAnswersByWorktree = forgetPartialAnswersByWorktree;
+exports.clearPartialAnswers = clearPartialAnswers;
+exports.beginSendAttempt = beginSendAttempt;
+exports.settleSendAttempt = settleSendAttempt;
+exports.hasMovedSendInFlight = hasMovedSendInFlight;
+exports.movePartialAnswers = movePartialAnswers;
 const prompt_key_1 = require("../detection/prompt-key");
 const logger_1 = require("../../lib/logger");
+const auto_yes_state_1 = require("../auto-yes-state");
+const global_state_1 = require("../global-state");
+const auto_yes_enter_fallback_state_1 = require("./auto-yes-enter-fallback-state");
 const logger = (0, logger_1.createLogger)('auto-yes-poller');
 /**
  * Issue #2995: what makes two ticks "the same prompt" for `warnOncePerFrame`.
@@ -50,3 +62,225 @@ function warnOncePerFrame(pollerState, frameKey, event, fields) {
     pollerState.lastSkipWarnKey = key;
     logger.warn(event, fields);
 }
+/**
+ * Which prompt a stopped answer is about (Issue #3706): the type, the question,
+ * the option labels and `approvalTarget` — what {@link promptFrameKey} tells
+ * apart — but NOT where the cursor is. The keys that were sent may have moved
+ * the cursor themselves (a `Down` whose Enter was withheld), and that must not
+ * make the same list read as a new one; a different list or a different command
+ * under the same question is a new prompt and is answered.
+ */
+function partialAnswerScreenKey(promptData) {
+    const options = promptData.type === 'multiple_choice'
+        ? promptData.options.map((o) => `${o.number}.${o.label}`).join('\n')
+        : promptData.options.join('\n');
+    return [(0, prompt_key_1.generatePromptKey)(promptData), options, withoutCursorMarks(promptData.approvalTarget ?? '')].join('\u0000');
+}
+/**
+ * `approvalTarget` with the cursor taken out: the generic parser copies the
+ * option panel into it, `❯` row included, so a moved cursor would otherwise
+ * read as another prompt. Leading indentation goes too — the cursor row is the
+ * one indented differently.
+ */
+function withoutCursorMarks(text) {
+    return text
+        .split('\n')
+        .map((line) => line.replace(/^[\s\u276F\u203A>\u25B6\u25BA\u25CF\u25CB\u25C9\u2192]+/u, ''))
+        .join('\n');
+}
+/** compositeKey -> the answer stopped part-way. globalThis for hot reload (#153). */
+const partialAnswers = (0, global_state_1.getOrInitGlobal)('__autoYesPartialAnswers', () => new Map());
+/**
+ * The answer stopped part-way that still applies: same session epoch, and the
+ * caller checks the prompt. Null when none, or when it was about another session.
+ */
+function getPartialAnswer(compositeKey, epoch) {
+    const partial = partialAnswers.get(compositeKey);
+    if (!partial)
+        return null;
+    if (partial.epoch !== epoch) {
+        partialAnswers.delete(compositeKey);
+        return null;
+    }
+    return partial;
+}
+/**
+ * Forget it: the prompt left the screen, another prompt came up, or the session ended.
+ *
+ * The sends still in flight that record under this key — moved here or not —
+ * are expired too (Issue #3713, re-instruction 2): they were registered before
+ * the screen they were typing at was seen gone, so their stop, coming back
+ * later, must not bring the memory back and leave the next confirmation of the
+ * same command unanswered. A send registered after this call is a new attempt
+ * and records as before. Expiring is the mark: it drops the attempt from the
+ * registry, so no per-key "forgotten up to seq" state has to outlive it.
+ *
+ * @param screenKey - Given when the memory is dropped because ANOTHER prompt is
+ *   on screen (re-instruction 3): only the sends at the forgotten memory's
+ *   screen are expired. A send at the screen now shown (Y, carried here by a
+ *   move while still in flight) stays — it keeps the successor off Y, and its
+ *   stop is still remembered when it comes back. Omitted (the prompt left the
+ *   screen), every send under the key is expired.
+ */
+function forgetPartialAnswer(compositeKey, screenKey) {
+    partialAnswers.delete(compositeKey);
+    for (const attempt of [...sendAttempts]) {
+        if (attempt.recordKey !== compositeKey)
+            continue;
+        if (screenKey !== undefined && attempt.screenKey !== screenKey)
+            continue;
+        expireSendAttempt(attempt);
+    }
+}
+/**
+ * {@link forgetPartialAnswer} for every instance of a worktree, and the sends
+ * still in flight there are expired (Issue #3713): a slow tick that comes back
+ * after the worktree's sessions went away records nothing. For the worktree
+ * being deleted only; disabling every agent keeps both (`stopAutoYesPollingByWorktree`'s
+ * `keepPartialAnswers`).
+ */
+function forgetPartialAnswersByWorktree(worktreeId) {
+    for (const key of (0, auto_yes_state_1.filterCompositeKeysByWorktree)([...partialAnswers.keys()], worktreeId)) {
+        partialAnswers.delete(key);
+    }
+    const inWorktree = new Set((0, auto_yes_state_1.filterCompositeKeysByWorktree)([...sendAttempts].map((attempt) => attempt.recordKey), worktreeId));
+    for (const attempt of [...sendAttempts]) {
+        if (inWorktree.has(attempt.recordKey))
+            expireSendAttempt(attempt);
+    }
+}
+/** Forget every one, and expire every send in flight: server shutdown, and a test seam. */
+function clearPartialAnswers() {
+    partialAnswers.clear();
+    for (const attempt of [...sendAttempts])
+        expireSendAttempt(attempt);
+}
+/** The sends in flight. globalThis for hot reload (#153), like the Map above. */
+const sendAttempts = (0, global_state_1.getOrInitGlobal)('__autoYesSendAttempts', () => new Set());
+const sendAttemptSeq = (0, global_state_1.getOrInitGlobal)('__autoYesSendAttemptSeq', () => ({ last: 0 }));
+/** Register a send about to start (the poller, before `sendPromptAnswer`). */
+function beginSendAttempt(compositeKey, screenKey, epoch) {
+    const attempt = {
+        seq: ++sendAttemptSeq.last,
+        screenKey,
+        recordKey: compositeKey,
+        recordEpoch: epoch,
+        moved: false,
+        state: 'pending',
+    };
+    sendAttempts.add(attempt);
+    return attempt;
+}
+/**
+ * The send came back. `keysSent` — it was stopped with keys already on the
+ * pane — records the partial answer under the attempt's key as it is now, when
+ * that key's session is still the one the keys went to; otherwise (sent in
+ * full, stopped before any key, or failed) only the attempt itself is removed.
+ * A second call, or a call on an expired attempt, does nothing.
+ */
+function settleSendAttempt(attempt, keysSent, at = Date.now()) {
+    if (attempt.state !== 'pending')
+        return;
+    attempt.state = 'settled';
+    sendAttempts.delete(attempt);
+    if (!keysSent)
+        return;
+    // A relaunch since (`beginAgentSession`): the process the keys went to is gone.
+    if ((0, auto_yes_enter_fallback_state_1.getEnterFallbackSessionEpoch)(attempt.recordKey) !== attempt.recordEpoch)
+        return;
+    // A send registered later (the successor's, after a move) already recorded
+    // the same session's newer screen: that is what is in the input now.
+    const recorded = partialAnswers.get(attempt.recordKey);
+    if (recorded !== undefined && recorded.epoch === attempt.recordEpoch && recorded.seq > attempt.seq)
+        return;
+    partialAnswers.set(attempt.recordKey, {
+        screenKey: attempt.screenKey,
+        epoch: attempt.recordEpoch,
+        at,
+        seq: attempt.seq,
+    });
+}
+function expireSendAttempt(attempt) {
+    if (attempt.state === 'pending')
+        attempt.state = 'expired';
+    sendAttempts.delete(attempt);
+}
+/**
+ * Is a send that a worktree ID move carried to `compositeKey` still in flight
+ * at this screen of this session (Issue #3713)? Its keys may already be on the
+ * pane, so the poller under the new key does not type at the same prompt until
+ * it comes back. Sends that were not moved are not counted: the paths without a
+ * move stay as they were.
+ */
+function hasMovedSendInFlight(compositeKey, epoch, screenKey) {
+    for (const attempt of sendAttempts) {
+        if (attempt.moved &&
+            attempt.recordKey === compositeKey &&
+            attempt.recordEpoch === epoch &&
+            attempt.screenKey === screenKey) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Carry the partial answers and the sends in flight of the sessions a worktree
+ * ID move renamed to their new keys (Issue #3713). Synchronous: the caller runs
+ * it right after the renames, before any poller restarts.
+ *
+ * Only what belongs to the session that moved goes: the source's epoch must
+ * still be `sourceEpoch`, and so must the record's. Every source is read before
+ * any destination is written, so a swap (A↔B) or a chain (A→B, B→C) moves each
+ * record once, with its own session. At a destination, what was recorded for
+ * the session that used to have that name is dropped — its process is not the
+ * one now there. The epochs themselves (and the Enter fallback's record) are not
+ * moved: a record takes the destination key's current epoch.
+ *
+ * @param moves - Only the renames that succeeded in both stages
+ * @returns The new keys that received a partial answer or a send in flight
+ */
+function movePartialAnswers(moves) {
+    const carried = moves
+        .filter((move) => move.oldKey !== move.newKey)
+        .map((move) => {
+        const current = (0, auto_yes_enter_fallback_state_1.getEnterFallbackSessionEpoch)(move.oldKey) === move.sourceEpoch;
+        const partial = partialAnswers.get(move.oldKey);
+        return {
+            move,
+            partial: current && partial !== undefined && partial.epoch === move.sourceEpoch ? partial : null,
+            attempts: current
+                ? [...sendAttempts].filter((attempt) => attempt.recordKey === move.oldKey && attempt.recordEpoch === move.sourceEpoch)
+                : [],
+        };
+    });
+    const carriedAttempts = new Set(carried.flatMap((entry) => entry.attempts));
+    // Detach every source first — only what is carried: a record the epochs
+    // left out (a session begun under the old key while the renames ran) stays.
+    for (const { move, partial } of carried) {
+        if (partial !== null && partialAnswers.get(move.oldKey) === partial)
+            partialAnswers.delete(move.oldKey);
+    }
+    // The destinations' previous sessions' records.
+    for (const { move } of carried) {
+        partialAnswers.delete(move.newKey);
+        for (const attempt of [...sendAttempts]) {
+            if (attempt.recordKey === move.newKey && !carriedAttempts.has(attempt))
+                expireSendAttempt(attempt);
+        }
+    }
+    // Then arrive.
+    const received = [];
+    for (const { move, partial, attempts } of carried) {
+        const epoch = (0, auto_yes_enter_fallback_state_1.getEnterFallbackSessionEpoch)(move.newKey);
+        if (partial !== null)
+            partialAnswers.set(move.newKey, { ...partial, epoch });
+        for (const attempt of attempts) {
+            attempt.recordKey = move.newKey;
+            attempt.recordEpoch = epoch;
+            attempt.moved = true;
+        }
+        if (partial !== null || attempts.length > 0)
+            received.push(move.newKey);
+    }
+    return received;
+}

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

@@ -0,0 +1,50 @@
+"use strict";
+/**
+ * The reason a poller stop is made for, when the stop function is called
+ * without one (Issue #3730).
+ *
+ * `stopAutoYesPolling(compositeKey, reason)` takes the reason as an argument,
+ * and every direct caller passes it. The lifecycle table
+ * (`lib/auto-yes-lifecycle`) cannot: it reaches the poller through the
+ * `auto-yes-manager` barrel, whose callers' tests mock it and pin the exact
+ * arguments (`stopAutoYesPolling(key)`, `stopAutoYesPollingByWorktree(id)`).
+ * So the table names its event here, around the call, and the poller reads it
+ * when no argument came. Synchronous only: the scope ends when `fn` returns.
+ *
+ * A module of its own, not part of the barrel, so mocking the barrel never
+ * mocks this away.
+ *
+ * @module lib/polling/auto-yes-poller-stop-reason
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withPollerStopReason = withPollerStopReason;
+exports.resolvePollerStopReason = resolvePollerStopReason;
+let scopedReason = null;
+/**
+ * Run `fn` with `reason` as the reason of every poller stop it makes that
+ * names none itself.
+ *
+ * @param reason - Why the pollers are being stopped
+ * @param fn - The synchronous stop call(s)
+ * @returns What `fn` returns
+ */
+function withPollerStopReason(reason, fn) {
+    const previous = scopedReason;
+    scopedReason = reason;
+    try {
+        return fn();
+    }
+    finally {
+        scopedReason = previous;
+    }
+}
+/**
+ * The reason to log for a stop: the explicit one, else the scope's, else
+ * `fallback`.
+ *
+ * @param explicit - The reason the caller passed, if any
+ * @param fallback - What to answer when neither says
+ */
+function resolvePollerStopReason(explicit, fallback) {
+    return explicit ?? scopedReason ?? fallback;
+}

package/dist/server/src/lib/polling/auto-yes-prompt-suppression.js

@@ -5,11 +5,22 @@
  * auto-yes-poller.ts (cycle) or `../tmux/tmux` (tmux import allowlist).
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_LOGGED_QUESTION_LENGTH = exports.COPILOT_FOLDER_TRUST_LAUNCH_DIALOG_ID = void 0;
 exports.suppressAndWarnOnce = suppressAndWarnOnce;
+exports.truncateForLog = truncateForLog;
 exports.suppressIfNotOursToAnswer = suppressIfNotOursToAnswer;
 exports.suppressUnclassifiedFrame = suppressUnclassifiedFrame;
+exports.suppressAntigravityTrustScreen = suppressAntigravityTrustScreen;
 const detect_1 = require("../detection/tools/codex/detect");
 const cli_patterns_1 = require("../detection/cli-patterns");
+const patterns_1 = require("../detection/tools/antigravity/patterns");
+const patterns_2 = require("../detection/tools/copilot/patterns");
+const antigravity_startup_trust_1 = require("../cli-tools/antigravity-startup-trust");
+const launch_dialog_1 = require("../cli-tools/launch-dialog");
+const launch_window_1 = require("../cli-tools/launch-window");
+const session_name_1 = require("../cli-tools/session-name");
+const auto_yes_suppression_reason_1 = require("./auto-yes-suppression-reason");
+const auto_yes_confirm_page_1 = require("./auto-yes-confirm-page");
 const auto_yes_suppression_state_1 = require("./auto-yes-suppression-state");
 const auto_yes_dialog_gate_1 = require("./auto-yes-dialog-gate");
 const auto_yes_poller_state_1 = require("./auto-yes-poller-state");
@@ -34,11 +45,128 @@ function suppressAndWarnOnce(prompt, suppression, warnFrameKey, event, detail) {
         ...detail,
     });
 }
+/** The `dialog` that copilot's folder-trust suppression records (Issue #3790). */
+exports.COPILOT_FOLDER_TRUST_LAUNCH_DIALOG_ID = 'copilot-folder-trust';
+/** How much of a prompt's question a log line carries (Issue #3497). */
+exports.MAX_LOGGED_QUESTION_LENGTH = 500;
 /**
- * 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.
+ * `question` cut to {@link MAX_LOGGED_QUESTION_LENGTH}, for a log line.
+ * Exported for `poller:response-sent` (Issue #3748).
+ */
+function truncateForLog(question) {
+    return question.length > exports.MAX_LOGGED_QUESTION_LENGTH
+        ? `${question.slice(0, exports.MAX_LOGGED_QUESTION_LENGTH)}…`
+        : question;
+}
+/**
+ * Whether the launch still owns its startup confirmation for this instance:
+ * its window is open (Issue #3776), or it pressed the confirming key less than
+ * `LAUNCH_DIALOG_PRESS_SETTLE_MS` ago and the agent may not have redrawn yet —
+ * the window can close in between (Issue #3790).
+ */
+function isLaunchStillAnswering(cliToolId, prompt) {
+    let sessionName;
+    try {
+        sessionName = (0, session_name_1.resolveSessionName)(cliToolId, prompt.worktreeId, prompt.instanceId);
+    }
+    catch {
+        // An id that would not make a session name was never launched here.
+        return false;
+    }
+    return (0, launch_window_1.isLaunchWindowOpen)(sessionName) || (0, launch_window_1.isLaunchDialogPressSettling)(sessionName);
+}
+/**
+ * Issue #3776: whether the prompt the poller is about to answer is gemini's
+ * folder-trust dialog itself — its parsed options are the declared option
+ * rows — rather than another prompt sharing the screen with it (the
+ * authentication picker under a dismissed dialog, a permission prompt under a
+ * reply that quotes the question).
+ */
+function isGeminiTrustPrompt(promptData) {
+    if (promptData.type !== 'multiple_choice')
+        return false;
+    const { optionRow, minOptionRows } = launch_dialog_1.GEMINI_TRUST_LAUNCH_DIALOG;
+    return promptData.options.filter((o) => optionRow.test(`${o.number}. ${o.label}`)).length >= minOptionRows;
+}
+/**
+ * Issue #3776: whether gemini's folder-trust dialog on this frame is left to
+ * the launch (step 3). Judged only for a prompt whose options are the dialog's
+ * declared rows ({@link isGeminiTrustPrompt}): a reply quoting the question
+ * over another prompt, or the authentication picker under a dismissed dialog,
+ * is answered as any prompt is.
+ *
+ * Left alone by default — the poller answers only when nothing else will and
+ * the answer is the safe one:
+ * - While the launch window is open (`cli-tools/launch-window`), never: the
+ *   launch answers it, and an answered dialog stays drawn above gemini's
+ *   restart line, where a `1` lands on whatever the restart draws next. Nor
+ *   for a while after the launch's Enter, window or not (Issue #3790,
+ *   {@link isLaunchStillAnswering}).
+ * - After it — the launch's Enter did not land, or gemini drew the dialog late
+ *   (an auto-update, a slow start) — only when the prompt's default (the
+ *   cursor row, which is what the poller sends) is `1. Trust folder`, and,
+ *   when the screen reads as the declared dialog, the launch's own reading is
+ *   `press` (not a dismissed dialog).
+ *
+ * A screen that does not read as the dialog (the wording changed, the options
+ * sit further below the question than declared) is not a reason to answer
+ * (review of #3776): with the cursor on `3. Don't trust` the poller's default
+ * would write that answer for good.
+ */
+function isGeminiTrustDialogLeftToLaunch(prompt, frame) {
+    const { promptData } = prompt;
+    if (promptData.type !== 'multiple_choice' || !isGeminiTrustPrompt(promptData))
+        return false;
+    if (isLaunchStillAnswering('gemini', prompt))
+        return true;
+    const defaultOption = promptData.options.find((o) => o.isDefault);
+    const defaultIsSafe = defaultOption !== undefined &&
+        launch_dialog_1.GEMINI_TRUST_LAUNCH_DIALOG.safeRow.test(`${defaultOption.number}. ${defaultOption.label}`);
+    if (!defaultIsSafe)
+        return true;
+    if (!(0, launch_dialog_1.isLaunchDialogDrawn)(launch_dialog_1.GEMINI_TRUST_LAUNCH_DIALOG, frame.clean))
+        return false;
+    if (!(0, launch_dialog_1.isLaunchDialogOpen)(launch_dialog_1.GEMINI_TRUST_LAUNCH_DIALOG, frame.clean))
+        return true;
+    return (0, launch_dialog_1.decideLaunchDialog)(launch_dialog_1.GEMINI_TRUST_LAUNCH_DIALOG, frame.clean).action !== 'press';
+}
+/**
+ * Issue #3790: whether copilot's folder-trust dialog on this frame is left to
+ * the launch (step 3), as gemini's is. The launch confirms it with a bare `1`
+ * (`CopilotTool.answerFolderTrustDialog`); the poller answered `1` + Enter
+ * beside it, and when the launch's `1` landed first, the poller's was typed
+ * into the composer the dismissal revealed and submitted as a user message
+ * (measured on 1.0.91, private tmux socket and HOME).
+ *
+ * Judged only when the frame carries both of the dialog's anchors and the
+ * prompt's options are its rows: a reply quoting the question over another
+ * prompt is answered as any prompt is. Left alone while the launch is still
+ * answering ({@link isLaunchStillAnswering}); after it — the launch's `1` did
+ * not land, or copilot drew the dialog late — the poller's default goes through
+ * only when it is the session-only `1. Yes` in the declared order
+ * (`isCopilotFolderTrustDialog`). `2.` writes `trustedFolders` into the
+ * machine-wide `~/.copilot/config.json`.
+ */
+function isCopilotTrustDialogLeftToLaunch(prompt, frame) {
+    const { promptData } = prompt;
+    if (promptData.type !== 'multiple_choice')
+        return false;
+    if (!patterns_2.COPILOT_FOLDER_TRUST_ANCHORS.every((anchor) => frame.clean.includes(anchor)))
+        return false;
+    const trustRows = promptData.options.filter((o) => patterns_2.COPILOT_FOLDER_TRUST_OPTION_LABEL_PATTERN.test(o.label));
+    if (trustRows.length < 2)
+        return false;
+    if (isLaunchStillAnswering('copilot', prompt))
+        return true;
+    const defaultOption = promptData.options.find((o) => o.isDefault);
+    const defaultIsSessionOnly = defaultOption?.number === 1 && defaultOption.label === 'Yes';
+    return !(defaultIsSessionOnly && (0, patterns_2.isCopilotFolderTrustDialog)(frame.clean));
+}
+/**
+ * Issue #3214: steps 3, 3.2, 3.3 (Issue #3497) 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
@@ -68,7 +196,24 @@ function suppressIfNotOursToAnswer(prompt, frame) {
     // 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;
+    //
+    // Issue #3776: gemini's folder-trust question too. The generic parser reads
+    // it as a multiple choice whose default is the cursor row, so the poller
+    // answered `1` beside the launch's own Enter (the second keypress then fell
+    // on the restarted gemini's authentication picker), and answered `3` —
+    // `Don't trust`, written for good — when the cursor sat there. The launch
+    // confirms only `1. Trust folder` (`cli-tools/launch-dialog`). See
+    // {@link isGeminiTrustDialogLeftToLaunch} for when the poller may answer.
+    //
+    // Issue #3790: copilot's folder-trust question too, whose launch answers a
+    // bare `1` (see {@link isCopilotTrustDialogLeftToLaunch}).
+    const launchDialog = cliToolId === 'codex'
+        ? (0, cli_patterns_1.getCodexLifecycleDialog)(frame)
+        : cliToolId === 'gemini' && isGeminiTrustDialogLeftToLaunch(prompt, frame)
+            ? launch_dialog_1.GEMINI_TRUST_LAUNCH_DIALOG.id
+            : cliToolId === 'copilot' && isCopilotTrustDialogLeftToLaunch(prompt, frame)
+                ? exports.COPILOT_FOLDER_TRUST_LAUNCH_DIALOG_ID
+                : 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.
@@ -86,6 +231,34 @@ function suppressIfNotOursToAnswer(prompt, 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.3. Issue #3497: Command Code's `AskUserQuestion` confirm page
+    // (`❯ 1. Submit` / `2. Cancel` under the question's tab strip) is not ours
+    // to answer. `Submit` picks nothing — it commits whatever stands as the
+    // answers, and on Kewton/Musunest#283 that was the worker's own proposal,
+    // which the worker then implemented as though a human had approved it. The
+    // full Review page is already declined by the reader (#2755 §7); a frame
+    // without its `← to go back and edit` row reaches the generic parser, and a
+    // question whose only choices are the pair is read by the question reader —
+    // both as `multiple_choice` with `Submit` as the default, answered `1`. Default, no setting: free-text questions go back to a human.
+    // The status path still publishes the prompt, so the human sees it.
+    //
+    // Issue #3748: Claude's confirmation page (`Ready to submit your answers?` /
+    // `❯ 1. Submit answers` / `2. Cancel`) is the same page and is declined the
+    // same way. Judged by `isAutoYesDeclinedConfirmPage`, which the browser's
+    // fallback (`useAutoYes`) asks too, and recorded with a reason of its own,
+    // `question-confirm-page`, which `cmate wait` names as such (it reused
+    // `unclassified-frame`, whose wording says no detector recognised the frame).
+    if ((0, auto_yes_confirm_page_1.isAutoYesDeclinedConfirmPage)(cliToolId, frame)) {
+        suppressAndWarnOnce(prompt, { reason: auto_yes_suppression_reason_1.QUESTION_CONFIRM_PAGE_SUPPRESSION_REASON, mode: null, promptType: promptData.type }, `${frameKey}\u0000question-confirm-page`, 'poller:auto-yes-skipped-question-confirm', {
+            reason: auto_yes_suppression_reason_1.QUESTION_CONFIRM_PAGE_SUPPRESSION_REASON,
+            promptType: promptData.type,
+            question: truncateForLog(promptData.question),
+            options: promptData.type === 'multiple_choice'
+                ? promptData.options.map((option) => `${option.number}. ${option.label}`)
+                : [...promptData.options],
+        });
+        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 --
@@ -123,3 +296,45 @@ function suppressUnclassifiedFrame(prompt, dialogGate) {
         gateMode: dialogGate.mode,
     });
 }
+/**
+ * Issue #3757: agy's startup folder-trust screen, which the tick read as no
+ * prompt at all — it is unnumbered, so neither agy's dialog reader nor the
+ * generic parser reads it, and the tick never got as far as the dialog gate or
+ * the Enter fallback. The status path still calls the pane `waiting`, so the
+ * prompt Push opened a wait that, with nothing recorded, it held as "Auto-Yes
+ * is answering" until the ten-minute reminder.
+ *
+ * Not answered here: the screen belongs to the launch, which confirms it with
+ * one Enter — in its own window, or through the next send when agy drew it
+ * later (`cli-tools/antigravity-startup-trust`). A second sender of that Enter
+ * here could press it twice. What this does is record the reason, so the gate
+ * notifies and `cmate wait` names the screen.
+ *
+ * Inside the launch window (`isStartupWindowOpen`) nothing is recorded: the
+ * window confirms the screen within a second or two, and a record would make
+ * the prompt Push ring for a screen that was never a human's. Outside it — the
+ * window ended (with the Enter owed, or not) or this process never launched the
+ * session — it is recorded.
+ *
+ * @param frame - The tick's one normalised frame (Issue #3183)
+ * @param sessionName - The instance's tmux session, for the launch window
+ * @returns true when the frame is the trust screen (recorded or not)
+ */
+function suppressAntigravityTrustScreen(worktreeId, instanceId, pollerState, frame, sessionName) {
+    if (!(0, patterns_1.isAntigravityTrustScreen)(frame.lastLines))
+        return false;
+    if ((0, antigravity_startup_trust_1.isStartupWindowOpen)(sessionName) && !(0, antigravity_startup_trust_1.isStartupTrustPending)(sessionName))
+        return true;
+    (0, auto_yes_suppression_state_1.recordPolicySuppression)(worktreeId, 'antigravity', instanceId, {
+        reason: auto_yes_suppression_reason_1.STARTUP_TRUST_UNHANDLED_SUPPRESSION_REASON,
+        mode: null,
+        promptType: 'multiple_choice',
+    });
+    (0, auto_yes_poller_state_1.warnOncePerFrame)(pollerState, 'antigravity-startup-trust', 'poller:auto-yes-skipped-startup-trust', {
+        worktreeId,
+        cliToolId: 'antigravity',
+        instanceId,
+        reason: auto_yes_suppression_reason_1.STARTUP_TRUST_UNHANDLED_SUPPRESSION_REASON,
+    });
+    return true;
+}

package/dist/server/src/lib/polling/auto-yes-suppression-reason.js

@@ -1,2 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.NO_HOOK_RECEIPT_SUPPRESSION_REASON = exports.QUESTION_CONFIRM_PAGE_SUPPRESSION_REASON = exports.STARTUP_TRUST_UNHANDLED_SUPPRESSION_REASON = exports.PARTIAL_ANSWER_SUPPRESSION_REASON = exports.CONTRACT_SUPPRESSION_REASONS = void 0;
+/**
+ * Issue #3796: the reasons `resolveAutoAnswerWithPolicy` returns — the contract's
+ * verdict on the prompt as it is NOW, which a later tick re-evaluates, as
+ * opposed to a reason that remembers an event (`partial-answer`).
+ */
+exports.CONTRACT_SUPPRESSION_REASONS = new Set([
+    'mode-off',
+    'deny-pattern',
+    'deny-pattern-unusable',
+    'type-not-allowed',
+]);
+/** Issue #3706: the reason the poller records for an answer stopped part-way. */
+exports.PARTIAL_ANSWER_SUPPRESSION_REASON = 'partial-answer';
+/** Issue #3757: the reason the poller records over agy's unanswered trust screen. */
+exports.STARTUP_TRUST_UNHANDLED_SUPPRESSION_REASON = 'startup-trust-unhandled';
+/** Issue #3748: the reason the poller records over an `AskUserQuestion` confirm page. */
+exports.QUESTION_CONFIRM_PAGE_SUPPRESSION_REASON = 'question-confirm-page';
+/** Issue #3767: the reason the poller records over an agy dialog with no matching hook receipt. */
+exports.NO_HOOK_RECEIPT_SUPPRESSION_REASON = 'no-hook-receipt';

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

@@ -25,6 +25,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.recordPolicySuppression = recordPolicySuppression;
 exports.getLastPolicySuppression = getLastPolicySuppression;
+exports.forgetPolicySuppression = forgetPolicySuppression;
 exports.clearPolicySuppressions = clearPolicySuppressions;
 const auto_yes_state_1 = require("../../lib/auto-yes-state");
 const global_state_1 = require("../global-state");
@@ -49,6 +50,15 @@ function recordPolicySuppression(worktreeId, cliToolId, instanceId, suppression,
 function getLastPolicySuppression(worktreeId, cliToolId, instanceId) {
     return lastPolicySuppressions.get((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId)) ?? null;
 }
+/**
+ * Drop the record of one session (Issue #3796): the reason it gives no longer
+ * holds for the prompt still on screen (the contract that withheld it changed),
+ * so leaving it to age out would have `cmate wait` report a stale reason for up
+ * to a minute.
+ */
+function forgetPolicySuppression(worktreeId, cliToolId, instanceId) {
+    lastPolicySuppressions.delete((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId));
+}
 /** Drop every recorded suppression. Test seam. */
 function clearPolicySuppressions() {
     lastPolicySuppressions.clear();