commandmate 0.47.0 → 0.48.0

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

@@ -0,0 +1,192 @@
+"use strict";
+/**
+ * Auto-Yes poller state store and tick generation (Issue #3783: split out of
+ * `auto-yes-poller.ts`, which re-exports the public names).
+ *
+ * Does not statically import `auto-yes-poller.ts` (no cycle outside the
+ * baseline in `import-cycles-baseline-3482`, which does not count dynamic
+ * `import()`).
+ *
+ * @module lib/polling/auto-yes-poller-generation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autoYesPollerStates = void 0;
+exports.getPollerState = getPollerState;
+exports.getActivePollerCount = getActivePollerCount;
+exports.getLastServerResponseTimestamp = getLastServerResponseTimestamp;
+exports.isPollerActive = isPollerActive;
+exports.updateLastServerResponseTimestamp = updateLastServerResponseTimestamp;
+exports.resetErrorCount = resetErrorCount;
+exports.ownedPollerState = ownedPollerState;
+exports.isPollerCurrent = isPollerCurrent;
+exports.isTickCurrent = isTickCurrent;
+exports.isSameSession = isSameSession;
+exports.isDuplicatePrompt = isDuplicatePrompt;
+exports.reserveDuplicateRetry = reserveDuplicateRetry;
+exports.isDuplicateRetryOf = isDuplicateRetryOf;
+exports.releaseDuplicateRetry = releaseDuplicateRetry;
+const auto_yes_enter_fallback_1 = require("./auto-yes-enter-fallback");
+const auto_yes_state_1 = require("../auto-yes-state");
+const global_state_1 = require("../global-state");
+const auto_yes_manual_answer_1 = require("./auto-yes-manual-answer");
+/** In-memory storage for poller states (globalThis for hot reload persistence) */
+exports.autoYesPollerStates = (0, global_state_1.getOrInitGlobal)('__autoYesPollerStates', () => new Map());
+// =============================================================================
+// Poller State Accessors (compositeKey-based)
+// =============================================================================
+/**
+ * Get poller state by composite key.
+ *
+ * @param compositeKey - Composite key (worktreeId:cliToolId)
+ * @returns Poller state or undefined
+ */
+function getPollerState(compositeKey) {
+    return exports.autoYesPollerStates.get(compositeKey);
+}
+/**
+ * Get the number of active pollers.
+ */
+function getActivePollerCount() {
+    return exports.autoYesPollerStates.size;
+}
+/**
+ * Get the last server response timestamp for a composite key.
+ *
+ * Issue #525: Changed from (worktreeId) to (compositeKey).
+ *
+ * @param compositeKey - Composite key (worktreeId:cliToolId)
+ * @returns Timestamp (Date.now()) of the last server response, or null if none
+ */
+function getLastServerResponseTimestamp(compositeKey) {
+    const pollerState = getPollerState(compositeKey);
+    return pollerState?.lastServerResponseTimestamp ?? null;
+}
+/**
+ * Check if a server-side auto-yes poller is active for a composite key.
+ *
+ * Issue #525: Changed from (worktreeId) to (compositeKey).
+ *
+ * @param compositeKey - Composite key (worktreeId:cliToolId)
+ * @returns true if a poller is actively running
+ */
+function isPollerActive(compositeKey) {
+    return exports.autoYesPollerStates.has(compositeKey);
+}
+/**
+ * Update the last server response timestamp.
+ *
+ * @param compositeKey - Composite key
+ * @param timestamp - Timestamp value (Date.now())
+ */
+function updateLastServerResponseTimestamp(compositeKey, timestamp, owner) {
+    const pollerState = ownedPollerState(compositeKey, owner);
+    if (pollerState) {
+        pollerState.lastServerResponseTimestamp = 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
+ * @param owner - The tick's own poller state (Issue #3706); see {@link ownedPollerState}
+ */
+function resetErrorCount(compositeKey, owner) {
+    const pollerState = ownedPollerState(compositeKey, owner);
+    if (pollerState) {
+        pollerState.consecutiveErrors = 0;
+        pollerState.currentInterval = auto_yes_state_1.POLLING_INTERVAL_MS;
+    }
+}
+/**
+ * The poller state under `compositeKey`, but only when it is `owner` — the
+ * tick's own (Issue #3706). Without `owner` (callers outside a tick, and tests
+ * driving `detectAndRespondToPrompt` with a hand-built state) it is the plain
+ * by-key read this always was.
+ */
+function ownedPollerState(compositeKey, owner) {
+    const pollerState = getPollerState(compositeKey);
+    if (owner !== undefined && pollerState !== owner)
+        return undefined;
+    return pollerState;
+}
+/** Is the tick's poller still the one under its key (not stopped, not replaced)? */
+function isPollerCurrent(generation) {
+    return getPollerState(generation.compositeKey) === generation.pollerState;
+}
+/**
+ * May the tick still act: its poller, its grant (the same enable, not expired)
+ * and its session (no relaunch since) are all still the ones it started under,
+ * and no person has begun answering on the instance since (Issue #3821).
+ * Checked after capture, after each wait before a key, and inside the send.
+ */
+function isTickCurrent(generation) {
+    if (!isPollerCurrent(generation))
+        return false;
+    // `getAutoYesState` returns the stored object until it expires, when it
+    // stores (and returns) a disabled one — so an expiry fails identity too.
+    const grant = (0, auto_yes_state_1.getAutoYesState)(generation.worktreeId, generation.cliToolId, generation.instanceId);
+    if (grant !== generation.grant || !grant.enabled)
+        return false;
+    // Issue #3821: a person began answering on this instance since the tick started
+    // (Issue #3880: or a person's send ended with keys maybe on the pane, holding it).
+    if ((generation.manualAnswerSeq ?? 0) !== (0, auto_yes_manual_answer_1.getManualAnswerSeq)(generation.compositeKey))
+        return false;
+    return isSameSession(generation);
+}
+/**
+ * Is the session the tick answered still the one it started on (Issue #3706)?
+ * What the follow-ups of an answer already sent — the response poller restart,
+ * the terminal push — are judged by: a disable after the keys landed does not
+ * un-send them, a relaunch does make them about another process.
+ */
+function isSameSession(generation) {
+    return (0, auto_yes_enter_fallback_1.getEnterFallbackSessionEpoch)(generation.compositeKey) === generation.sessionEpoch;
+}
+/**
+ * Check if the given prompt has already been answered recently.
+ *
+ * @param pollerState - Current poller state
+ * @param promptKey - Composite key of the current prompt
+ * @returns true if the prompt key matches and is within the retry expiry window
+ */
+function isDuplicatePrompt(pollerState, promptKey) {
+    if (pollerState.lastAnsweredPromptKey !== promptKey)
+        return false;
+    if (pollerState.lastAnsweredAt === null)
+        return false;
+    return (Date.now() - pollerState.lastAnsweredAt) < auto_yes_state_1.DUPLICATE_RETRY_EXPIRY_MS;
+}
+/**
+ * Issue #3791 (review N1): publish that the duplicate guard held back the
+ * prompt on screen on this tick ({@link isDuplicatePrompt} was true), for the
+ * push gate to hold the wait until the guard's retry. Only the guard's own
+ * verdict sets it: an answer alone (`lastAnsweredAt`) says nothing about the
+ * screen now up — another prompt, or a failed tick, is not held by the guard.
+ */
+function reserveDuplicateRetry(pollerState, promptKey, now) {
+    if (pollerState.lastAnsweredAt === null)
+        return;
+    pollerState.duplicateRetryReservation = { promptKey, answeredAt: pollerState.lastAnsweredAt, observedAt: now };
+}
+/**
+ * Issue #3791 (review N3): is `promptKey` the prompt the guard reserved, its
+ * guard since expired — the tick about to send the retry the reservation
+ * waited for? Its reservation is then kept until that send is settled.
+ */
+function isDuplicateRetryOf(pollerState, promptKey) {
+    const reservation = pollerState.duplicateRetryReservation;
+    return (reservation !== undefined &&
+        reservation !== null &&
+        reservation.promptKey === promptKey &&
+        reservation.answeredAt === pollerState.lastAnsweredAt);
+}
+/**
+ * Issue #3791 (review N1): the tick did not hold the prompt back with the
+ * guard — another screen, no prompt, a failed tick, no session — so the wait
+ * is no longer the guard's retry to wait for.
+ */
+function releaseDuplicateRetry(pollerState) {
+    pollerState.duplicateRetryReservation = null;
+}

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

@@ -0,0 +1,324 @@
+"use strict";
+/**
+ * Auto-Yes poller: the agy hook-receipt bookkeeping and its withheld log lines
+ * (Issue #3783: split out of `auto-yes-poller.ts`, which re-exports the public
+ * names).
+ *
+ * Does not statically import `auto-yes-poller.ts` (no cycle outside the
+ * baseline in `import-cycles-baseline-3482`, which does not count dynamic
+ * `import()`).
+ *
+ * @module lib/polling/auto-yes-poller-receipt-log
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withheldNoReceiptLoggedAt = void 0;
+exports.logIfWithheldForWantOfReceipt = logIfWithheldForWantOfReceipt;
+exports.noteAnswerSent = noteAnswerSent;
+exports.receiptEpisodeOfSend = receiptEpisodeOfSend;
+exports.noHookReceiptHint = noHookReceiptHint;
+const antigravity_receipt_episodes_1 = require("./antigravity-receipt-episodes");
+const antigravity_permission_receipts_1 = require("./antigravity-permission-receipts");
+const auto_yes_resolver_1 = require("./auto-yes-resolver");
+const auto_yes_policy_1 = require("./auto-yes-policy");
+const logger_1 = require("../../lib/logger");
+const global_state_1 = require("../global-state");
+const prompt_screen_key_1 = require("../detection/prompt-screen-key");
+const auto_yes_poller_state_1 = require("./auto-yes-poller-state");
+const auto_yes_suppression_reason_1 = require("./auto-yes-suppression-reason");
+const auto_yes_suppression_state_1 = require("./auto-yes-suppression-state");
+const logger = (0, logger_1.createLogger)('auto-yes-poller');
+/**
+ * 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.
+ */
+exports.withheldNoReceiptLoggedAt = (0, global_state_1.getOrInitGlobal)('__autoYesWithheldNoReceiptLoggedAt', () => new Map());
+/**
+ * Least gap between two `antigravity-autoyes-withheld-no-hook-receipt` lines for
+ * one instance. `antigravity-autoyes-withheld-by-policy` (Issue #3724) shares it.
+ */
+const WITHHELD_NO_RECEIPT_LOG_INTERVAL_MS = 60_000;
+/**
+ * Say, once a minute, that Auto-Yes left an agy dialog alone for want of a hook
+ * receipt (Issue #2857).
+ *
+ * `detectPromptOnCleanFrame` hands a frame the receipt gate (#2849) withholds
+ * back as an ordinary `isPrompt: false`, so the poller cannot tell "no dialog on
+ * the pane" from "a dialog agy never asked us about" by looking at the result.
+ * The gate is the ONLY thing `receiptScope` changes, so the same frame read
+ * without it answering a prompt is exactly the withheld case. That second
+ * reading is taken only after the cheap tests: no receipt for this instance in
+ * the window (with one, the gate let the frame through and a no-prompt result is
+ * a real one) and no line for it in the last minute.
+ *
+ * Why it is worth a line: a machine whose `~/.gemini/config/hooks.json` points at
+ * another server (#2622) never sends us the question, and every real dialog then
+ * waits for a human with no sign of why. The line names the file to look at.
+ *
+ * A stale receipt does not always mean that, though (Issue #3724): a dialog the
+ * contract's autoYes withheld got its receipt, the server answered `ask`, and
+ * the dialog outlived the window. When `resolveAutoAnswerWithPolicy` on the
+ * ungated reading suppresses the answer by contract (the base rules would have
+ * answered it), the line is `antigravity-autoyes-withheld-by-policy` instead,
+ * naming the reason, the mode and the task. Both share the limit.
+ * The response-checker's own `antigravity-dialog-no-recent-receipt` stays at
+ * debug — it prints on every tick the same pane is read again.
+ *
+ * Issue #3820: says what it saw, for the confirmation ledger. The gated
+ * reading's `isPrompt: false` is not "the dialog is gone": past the receipt
+ * window the dialog is still up, and the ledger keeps it as the same
+ * confirmation. Nothing here changes on that account — the return value is the
+ * ungated reading this function already took, and the reason it recorded.
+ *
+ * @param compositeKey - The instance's key, for the once-a-minute limit
+ * Issue #3880: a person's send that may have left keys on the pane holds the
+ * dialog (`partial-answer`), but no tick inside the window published it — the
+ * manual hold kept them off it — so there is no record to re-stamp. Given that
+ * hold's screen, a dialog still up at it is withheld as `partial-answer` here,
+ * before the contract and the receipt (as on the tick, step 2.5).
+ *
+ * @param readWithoutGate - The same frame read without `receiptScope`
+ * @param personHoldScreenKey - The screen of a person's hold the tick had
+ *   (`PartialAutoYesAnswer.byPerson`), else null
+ * @returns The prompt the ungated reading saw, with the reason this call
+ *   recorded or kept for it (null when none: a dialog the gate accepted and is
+ *   waiting to be answered); null when no dialog was read past the gate
+ */
+function logIfWithheldForWantOfReceipt(worktreeId, instanceId, compositeKey, readWithoutGate, personHoldScreenKey = null) {
+    // Issue #3767: the gate's own verdict for this tick's candidate. Null means it
+    // never saw one (no dialog), `ok` that it let the frame through.
+    let verdict = (0, antigravity_receipt_episodes_1.getAntigravityReceiptVerdict)(worktreeId, instanceId);
+    if (verdict?.ok)
+        return null;
+    const now = Date.now();
+    const ungated = readWithoutGate();
+    if (!ungated.isPrompt || !ungated.promptData)
+        return null;
+    const promptData = ungated.promptData;
+    // The gate was not consulted (the gated reading declined the frame on screen
+    // grounds alone) yet the frame reads as a prompt: judge it here.
+    verdict ??= (0, antigravity_receipt_episodes_1.judgeAntigravityPermissionReceipt)(worktreeId, instanceId, now);
+    if (verdict.ok)
+        return null;
+    if (personHoldScreenKey !== null && (0, auto_yes_poller_state_1.partialAnswerCovers)(personHoldScreenKey, (0, prompt_screen_key_1.promptScreenKey)(promptData))) {
+        (0, auto_yes_suppression_state_1.recordPolicySuppression)(worktreeId, 'antigravity', instanceId, {
+            reason: auto_yes_suppression_reason_1.PARTIAL_ANSWER_SUPPRESSION_REASON,
+            mode: null,
+            promptType: promptData.type,
+        });
+        return { promptData, reason: auto_yes_suppression_reason_1.PARTIAL_ANSWER_SUPPRESSION_REASON, keptPersonHold: true };
+    }
+    // Issue #3724: a contract that withholds the answer makes the server reply
+    // `ask`, so the dialog stays up past the receipt window. The cause is then the
+    // contract, not a hooks.json that points elsewhere. Judged exactly as the tick
+    // judges a prompt it can read — the base rules first, then the contract — so
+    // a prompt the base rules never answer (a checkbox, a typed option) is not
+    // blamed on the contract. Policy and task id come from one lookup.
+    // Issue #3822: a failed lookup stays unknown here, as it is for the tick, so
+    // this re-judgement withholds too instead of reading "no contract" and
+    // dropping the `policy-lookup-failed` record the tick made.
+    const { policy, taskId } = (0, auto_yes_policy_1.getSessionAutoYesPolicyLookupEntry)(worktreeId, 'antigravity', instanceId);
+    const mode = (0, auto_yes_resolver_1.policyLookupMode)(policy);
+    const resolution = (0, auto_yes_resolver_1.resolveAutoAnswerWithPolicy)(ungated.promptData, policy, 'antigravity');
+    // Issue #3767: `answered` is the dialog the gate already let through on this
+    // receipt, still up past the window. Unless the contract withheld it, that is
+    // not a missing receipt: neither recorded nor logged, nor counted for the limit.
+    // Issue #3789: `answered` is also a dialog accepted but never sent to (the
+    // tick recorded its own reason, if any, and that record is kept). One the
+    // poller DID send keys to and still up past the grace is `outlived`, which is
+    // recorded and logged like the others, so the stop is not a silent one.
+    // Issue #3796: the reason the poller recorded for this dialog (partial-answer,
+    // the contract, …) while it could still read it inside the window was not
+    // re-stamped once the window closed — the gated reading stopped seeing the
+    // prompt — so `cmate wait` dropped it as stale a minute later with the dialog
+    // still up. Re-stamped here on every tick the dialog stays — only while it
+    // still holds under this tick's evaluation — and kept over a `no-hook-receipt`
+    // for it: it is the more exact reason.
+    const keptPartialAnswer = refreshEpisodeSuppression(worktreeId, instanceId, verdict, resolution);
+    // Issue #3796 review D: a contract that withholds the prompt now is published
+    // whatever was recorded before — none at all (the window closed before the
+    // tick could read it, or an ended contract's record was dropped and a new one
+    // withholds it again) or another reason. Without it `cmate wait` read no
+    // reason and held the prompt as one Auto-Yes was answering. Only a partial
+    // answer still on screen comes first, as it does on the tick (step 2.5).
+    if (resolution.suppressedBy && !keptPartialAnswer) {
+        (0, auto_yes_suppression_state_1.recordPolicySuppression)(worktreeId, 'antigravity', instanceId, {
+            reason: resolution.suppressedBy,
+            mode,
+            promptType: ungated.promptData.type,
+            ...(resolution.pattern !== undefined ? { pattern: resolution.pattern } : {}),
+        });
+    }
+    const seen = (reason) => ({ promptData, reason });
+    // What stands recorded for the prompt after this call: a kept partial answer
+    // comes before the contract, as the record above.
+    const contractReason = keptPartialAnswer ? auto_yes_suppression_reason_1.PARTIAL_ANSWER_SUPPRESSION_REASON : resolution.suppressedBy;
+    if (!resolution.suppressedBy && (verdict.cause === 'answered' || keptPartialAnswer)) {
+        return seen(keptPartialAnswer ? auto_yes_suppression_reason_1.PARTIAL_ANSWER_SUPPRESSION_REASON : null);
+    }
+    const logDue = claimWithheldLogSlot(compositeKey, now);
+    if (resolution.suppressedBy) {
+        if (!logDue)
+            return seen(contractReason ?? null);
+        logger.info('antigravity-autoyes-withheld-by-policy', {
+            worktreeId,
+            instanceId: instanceId ?? 'antigravity',
+            reason: resolution.suppressedBy,
+            mode,
+            taskId,
+            hint: withheldHint(resolution.suppressedBy),
+        });
+        return seen(contractReason ?? null);
+    }
+    // Issue #3767: recorded on every tick (the record's `at` follows the prompt
+    // while it stays up), logged once a minute.
+    (0, auto_yes_suppression_state_1.recordPolicySuppression)(worktreeId, 'antigravity', instanceId, {
+        reason: auto_yes_suppression_reason_1.NO_HOOK_RECEIPT_SUPPRESSION_REASON,
+        mode: null,
+        promptType: ungated.promptData.type,
+    });
+    if (!logDue)
+        return seen(auto_yes_suppression_reason_1.NO_HOOK_RECEIPT_SUPPRESSION_REASON);
+    logger.info('antigravity-autoyes-withheld-no-hook-receipt', {
+        worktreeId,
+        instanceId: instanceId ?? 'antigravity',
+        windowMs: antigravity_permission_receipts_1.ANTIGRAVITY_PERMISSION_RECEIPT_WINDOW_MS,
+        hint: noHookReceiptHint(verdict, now),
+    });
+    return seen(auto_yes_suppression_reason_1.NO_HOOK_RECEIPT_SUPPRESSION_REASON);
+}
+/**
+ * The hint of `antigravity-autoyes-withheld-by-policy` for `reason`. Issue
+ * #3822: the base rules' withholding (`allow-once-unidentified`) is not the
+ * contract's, so the line does not send the operator to the contract for it.
+ */
+function withheldHint(reason) {
+    if (reason === auto_yes_suppression_reason_1.POLICY_LOOKUP_FAILED_SUPPRESSION_REASON) {
+        return '契約の照会に失敗したので答えていない。サーバーログの policy-lookup-failed を確認';
+    }
+    // Issue #3863: the other base-rule withholding, over a question's recommended option.
+    if (reason === auto_yes_suppression_reason_1.RECOMMENDED_OPTION_UNIDENTIFIED_SUPPRESSION_REASON) {
+        return '質問の推奨の選択肢を 1 つに特定できないので答えていない（基本の判定。契約の判定ではない）。画面で答える';
+    }
+    if ((0, auto_yes_suppression_reason_1.isBaseRuleSuppressionReason)(reason)) {
+        return '今回だけ許可の選択肢を 1 つに特定できないので答えていない（基本の判定。契約の判定ではない）。画面で答える';
+    }
+    return '契約の autoYes が答えを止めている。契約の autoYes を確認';
+}
+/**
+ * Whether a withheld line for `compositeKey` is due at `now` under the
+ * once-a-minute limit; when it is, entries past the interval are pruned and
+ * `now` is taken as this key's last line.
+ */
+function claimWithheldLogSlot(compositeKey, now) {
+    const lastLoggedAt = exports.withheldNoReceiptLoggedAt.get(compositeKey);
+    const logDue = lastLoggedAt === undefined || now - lastLoggedAt >= WITHHELD_NO_RECEIPT_LOG_INTERVAL_MS;
+    if (logDue) {
+        for (const [key, loggedAt] of exports.withheldNoReceiptLoggedAt) {
+            if (now - loggedAt >= WITHHELD_NO_RECEIPT_LOG_INTERVAL_MS)
+                exports.withheldNoReceiptLoggedAt.delete(key);
+        }
+        exports.withheldNoReceiptLoggedAt.set(compositeKey, now);
+    }
+    return logDue;
+}
+/**
+ * Issue #3796: keep the suppression the poller recorded during this dialog's
+ * episode current while the dialog it accepted (`answered` / `outlived`) is
+ * still up. Only a record made since the dialog was first read, and never the
+ * receipt gate's own `no-hook-receipt` (the caller records that itself). A
+ * record is kept only while its reason still holds NOW:
+ *
+ * - `partial-answer` remembers an event: it holds for as long as the dialog
+ *   the keys went to stays up (this episode), and is re-stamped here;
+ * - a contract reason is the contract's verdict on the prompt, re-evaluated on
+ *   every tick (`resolution`): no verdict (the contract ended, or now answers
+ *   it) drops the record — the dialog is then `answered` / `outlived` like any
+ *   other. A verdict is recorded by the caller (review D), whatever was here;
+ * - any other reason is left as it was recorded.
+ *
+ * @returns true when a `partial-answer` that still holds was re-stamped
+ */
+function refreshEpisodeSuppression(worktreeId, instanceId, verdict, resolution) {
+    if (verdict.cause !== 'answered' && verdict.cause !== 'outlived')
+        return false;
+    const own = (0, auto_yes_suppression_state_1.getLastPolicySuppression)(worktreeId, 'antigravity', instanceId);
+    if (own === null || own.reason === auto_yes_suppression_reason_1.NO_HOOK_RECEIPT_SUPPRESSION_REASON || !(own.at >= verdict.firstSeenAt)) {
+        return false;
+    }
+    if (own.reason === auto_yes_suppression_reason_1.PARTIAL_ANSWER_SUPPRESSION_REASON) {
+        // The memory is the episode's: the dialog the keys went to is still the one
+        // up (same episode, accepted on the same receipt). Not `getPartialAnswer`:
+        // the tick forgets it as soon as the gated reading stops seeing the prompt,
+        // which past the window is every tick.
+        // Issue #3798: re-stamped under the waiting episode it was recorded for
+        // (`episodeId` is carried over), not whichever is open now — the keys went
+        // to that wait's dialog.
+        const { at: _recordedAt, ...suppression } = own;
+        (0, auto_yes_suppression_state_1.recordPolicySuppression)(worktreeId, 'antigravity', instanceId, suppression);
+        return true;
+    }
+    if (auto_yes_suppression_reason_1.CONTRACT_SUPPRESSION_REASONS.has(own.reason) && !resolution.suppressedBy) {
+        (0, auto_yes_suppression_state_1.forgetPolicySuppression)(worktreeId, 'antigravity', instanceId);
+    }
+    return false;
+}
+/**
+ * Issue #3789: keys for an agy dialog the receipt gate accepted reached tmux.
+ * Only here does the gate start the grace after which a dialog still up is
+ * reported as `outlived`; the tick's `no_answer` exits (another server's session,
+ * a partial answer, the base rules or the contract not answering) never get
+ * here, so their own records are not overwritten by `no-hook-receipt`.
+ *
+ * Issue #3796: `interrupted` — the send began and was cut short (stopped
+ * part-way, or failed). Its keys may be on the pane and the receipt is spent,
+ * so the grace starts here too; without it the dialog stayed `answered`, and
+ * silent, for as long as it stayed up.
+ */
+function noteAnswerSent(cliToolId, worktreeId, instanceId, interrupted = false, forReceiptAt) {
+    if (cliToolId !== 'antigravity')
+        return;
+    (0, antigravity_receipt_episodes_1.markAntigravityAnswerSent)(worktreeId, instanceId, Date.now(), {
+        interrupted,
+        ...(forReceiptAt !== undefined ? { forReceiptAt } : {}),
+    });
+}
+/**
+ * Issue #3796 review: the agy episode a send is about to go to, read before
+ * its first await; null for other tools. Given back to {@link noteAnswerSent}
+ * however the send came back — whole, failed or cut short (review E) — so that
+ * only that episode is marked — the same
+ * idea as the Enter record's generation check in `tryEnterFallback`.
+ */
+function receiptEpisodeOfSend(cliToolId, worktreeId, instanceId) {
+    return cliToolId === 'antigravity' ? (0, antigravity_receipt_episodes_1.getAntigravityAcceptedReceiptAt)(worktreeId, instanceId) : null;
+}
+/**
+ * The hint for `antigravity-autoyes-withheld-no-hook-receipt` (Issue #3767):
+ * which of the withheld cases it was decides where to look.
+ */
+function noHookReceiptHint(verdict, now = Date.now()) {
+    const seconds = verdict.ageMs === null ? null : Math.round(verdict.ageMs / 1000);
+    // `lapsed` says how long ago, so from now: the line repeats once a minute.
+    const secondsAgo = verdict.lastReceiptAt === null ? null : Math.round((now - verdict.lastReceiptAt) / 1000);
+    switch (verdict.cause) {
+        case 'never':
+            return 'hook の受信が一度も無いため Auto-Yes は答えなかった。~/.gemini/config/hooks.json の向き先（#2622）を確認';
+        case 'late':
+            return `最後の受信から ${seconds} 秒後に確認が出た（窓 ${antigravity_permission_receipts_1.ANTIGRAVITY_PERMISSION_RECEIPT_WINDOW_MS / 1000} 秒の外）ため答えなかった。人が答える（auto-yes --disable → prompt --json → respond --expect-screen）。続くなら ~/.gemini/config/hooks.json の向き先（#2622）も確認`;
+        case 'lapsed':
+            return `最後の受信は ${secondsAgo} 秒前で途絶えている（hook が届かなくなった）。hooks.json の向き先（#2622）と agy の再起動を確認`;
+        case 'predates':
+            return '確認は最後の受信より前から画面に出ていた（引用か別の確認）ため答えなかった。人が答える';
+        case 'used':
+            return '最後の受信は直前の確認に使い済み。この確認に対する受信は無いため答えなかった。人が答える';
+        case 'outlived':
+            if (verdict.answerInterrupted === true) {
+                return `Auto-Yes が最後の受信の確認へ答えを送る途中で送信が止まり（キーの一部が入力に残っている可能性がある）、${antigravity_receipt_episodes_1.ANTIGRAVITY_ANSWERED_DIALOG_GRACE_MS / 1000} 秒を過ぎても確認が画面に残っている。未使用の受信が無いため、もう一度は答えない。人が答える（auto-yes --disable → prompt --json → respond --expect-screen）`;
+            }
+            return `Auto-Yes が最後の受信の確認へキーを送ってから ${antigravity_receipt_episodes_1.ANTIGRAVITY_ANSWERED_DIALOG_GRACE_MS / 1000} 秒を過ぎても、確認が画面に残っている。キーで確認が閉じなかったか、新しい受信の無い別の確認と入れ替わった（画面からは区別できない）。未使用の受信が無いため、もう一度は答えない。人が答える（auto-yes --disable → prompt --json → respond --expect-screen）`;
+        default:
+            return 'hook の受信記録が直近に無いため Auto-Yes は答えなかった。~/.gemini/config/hooks.json の向き先（#2622）を確認';
+    }
+}