commandmate 0.46.1 → 0.47.0

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

@@ -19,6 +19,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AUTO_YES_POLICY_CACHE_TTL_MS = void 0;
 exports.getSessionAutoYesPolicy = getSessionAutoYesPolicy;
+exports.getSessionAutoYesPolicyEntry = getSessionAutoYesPolicyEntry;
+exports.isAutoYesBlockedByPolicy = isAutoYesBlockedByPolicy;
+exports.isSessionAutoYesBlockedByContract = isSessionAutoYesBlockedByContract;
+exports.getSessionContractPolicySummary = getSessionContractPolicySummary;
 exports.invalidateSessionAutoYesPolicy = invalidateSessionAutoYesPolicy;
 exports.clearAutoYesPolicyCache = clearAutoYesPolicyCache;
 const db_1 = require("../../lib/db");
@@ -60,10 +64,10 @@ function readPolicy(worktreeId, cliToolId, instanceId) {
     try {
         const task = (0, db_1.getActiveTaskForInstance)((0, db_instance_1.getDbInstance)(), worktreeId, cliToolId, instanceId);
         if (!task)
-            return null;
+            return { policy: null, taskId: null };
         // Assignment, not a cast: a drift in TaskContractAutoYes fails the build here.
         const policy = task.contract.autoYes;
-        return policy;
+        return { policy, taskId: task.id };
     }
     catch (error) {
         logger.warn('policy-lookup-failed', {
@@ -72,7 +76,7 @@ function readPolicy(worktreeId, cliToolId, instanceId) {
             instanceId,
             error: error instanceof Error ? error.message : String(error),
         });
-        return null;
+        return { policy: null, taskId: null };
     }
 }
 /**
@@ -85,19 +89,69 @@ function readPolicy(worktreeId, cliToolId, instanceId) {
  * @returns The contract's autoYes block, or null when no contract governs this instance
  */
 function getSessionAutoYesPolicy(worktreeId, cliToolId, instanceId) {
+    return lookupEntry(worktreeId, cliToolId, instanceId).policy;
+}
+/**
+ * The policy and the id of the task it came from, read in ONE lookup (Issue
+ * #3724), so a log line naming both cannot pair one task's verdict with another
+ * task's id when the cache expires between two reads. `taskId` is null when no
+ * contract governs the instance.
+ */
+function getSessionAutoYesPolicyEntry(worktreeId, cliToolId, instanceId) {
+    const { policy, taskId } = lookupEntry(worktreeId, cliToolId, instanceId);
+    return { policy, taskId };
+}
+/**
+ * Whether the contract's policy keeps Auto-Yes from ever answering (Issue #3723).
+ *
+ * `mode: 'off'` only. `safe` / `allow-listed` still answer some prompts, and a
+ * null mode (or no contract) states nothing, so those are not blocked. The
+ * poller's resolver reaches the same verdict from the same policy.
+ */
+function isAutoYesBlockedByPolicy(policy) {
+    return policy?.mode === 'off';
+}
+/**
+ * Whether the contract governing this instance keeps Auto-Yes from answering
+ * (Issue #3723). The poller's own lookup ({@link getSessionAutoYesPolicyEntry})
+ * judged by {@link isAutoYesBlockedByPolicy}, so the list cannot read `blocked`
+ * for an instance the poller would answer, or the reverse.
+ */
+function isSessionAutoYesBlockedByContract(worktreeId, cliToolId, instanceId) {
+    return isAutoYesBlockedByPolicy(getSessionAutoYesPolicyEntry(worktreeId, cliToolId, instanceId).policy);
+}
+/**
+ * The contract policy of an agent instance in the shape the API returns, or null
+ * when no contract governs it. Policy and task id come from ONE
+ * {@link getSessionAutoYesPolicyEntry} lookup — the poller's cache — so the mode
+ * and the task it names are the same task's.
+ */
+function getSessionContractPolicySummary(worktreeId, cliToolId, instanceId) {
+    const { policy, taskId } = getSessionAutoYesPolicyEntry(worktreeId, cliToolId, instanceId);
+    if (!policy)
+        return null;
+    return {
+        taskId,
+        mode: policy.mode,
+        allowPromptTypes: policy.allowPromptTypes,
+        denyPatternCount: policy.denyPatterns.length,
+    };
+}
+function lookupEntry(worktreeId, cliToolId, instanceId) {
     const resolvedInstanceId = instanceId ?? cliToolId;
     const key = (0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, resolvedInstanceId);
     const now = Date.now();
     const cached = policyCache.get(key);
     if (cached && cached.expiresAt > now) {
-        return cached.policy;
+        return cached;
     }
-    const policy = readPolicy(worktreeId, cliToolId, resolvedInstanceId);
+    const { policy, taskId } = readPolicy(worktreeId, cliToolId, resolvedInstanceId);
     if (policyCache.size >= MAX_CACHE_ENTRIES) {
         purgeExpired(now);
     }
-    policyCache.set(key, { policy, expiresAt: now + exports.AUTO_YES_POLICY_CACHE_TTL_MS });
-    return policy;
+    const entry = { policy, taskId, expiresAt: now + exports.AUTO_YES_POLICY_CACHE_TTL_MS };
+    policyCache.set(key, entry);
+    return entry;
 }
 /**
  * Drop the cached policy for a composite key, so the next lookup re-reads the

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,5 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PARTIAL_ANSWER_SUPPRESSION_REASON = void 0;
+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();

package/dist/server/src/lib/polling/response-checker-dialog-gate.js

@@ -9,7 +9,7 @@ exports.isWithheldForWantOfReceipt = isWithheldForWantOfReceipt;
 exports.isNumberedDialogVouched = isNumberedDialogVouched;
 const logger_1 = require("../../lib/logger");
 const logger = (0, logger_1.createLogger)('response-poller');
-const antigravity_permission_receipts_1 = require("./antigravity-permission-receipts");
+const antigravity_receipt_episodes_1 = require("./antigravity-receipt-episodes");
 // Issue #2457: the same rollout table, `hasDialogRules` cross-check and
 // `detectDialog` seam Auto-Yes reads, reached through the presence helper rather
 // than through `evaluateAutoYesDialogGate` — see `isNumberedDialogVouched`.
@@ -36,7 +36,7 @@ const auto_yes_dialog_gate_1 = require("./auto-yes-dialog-gate");
 function isWithheldForWantOfReceipt(scope) {
     if (scope === undefined)
         return false;
-    if ((0, antigravity_permission_receipts_1.hasRecentAntigravityPermissionReceipt)(scope.worktreeId, 'antigravity', scope.instanceId))
+    if ((0, antigravity_receipt_episodes_1.judgeAntigravityPermissionReceipt)(scope.worktreeId, scope.instanceId).ok)
         return false;
     logger.debug('antigravity-dialog-no-recent-receipt', {
         worktreeId: scope.worktreeId,

package/dist/server/src/lib/polling/response-checker.js

@@ -228,6 +228,15 @@ function detectPromptOnCleanFrame(cleanOutput, cliToolId, precomputedLines, rawF
                 ? { isPrompt: false, cleanContent: cleanOutput.trim() }
                 : dialog;
         }
+        // Issue #3808: a numbered agy screen the reader declines — the login-method
+        // screen, a permission dialog whose `tab Amend` footer a narrow pane cut or
+        // left below the pane — is not handed to the generic parser either, which
+        // reads `> 1. Google OAuth` as an answerable option. Judged without the
+        // footer, so a missing footer cannot reopen the generic path. The status
+        // verdict publishes the same frame as unclassified (`tools/antigravity/detect.ts`).
+        if ((0, dialog_1.isAntigravityUnvouchedNumberedScreen)(cleanOutput)) {
+            return { isPrompt: false, cleanContent: cleanOutput.trim() };
+        }
     }
     // Issue #2522: Command Code's footer-less `AskUserQuestion`, read by the same
     // module `tools/command-code/detect.ts` publishes its status from — so the