commandmate 0.46.1 → 0.47.2

package/dist/server/src/lib/hooks/sources/copilot/source.js

@@ -215,6 +215,8 @@ exports.copilotAgentEventSource = (0, define_source_1.definePushHookSource)({
         // module comment above.
         sessionStartMayArriveLate: true,
         permissionReplyReleasesPrompt: false,
+        // Issue #3820: an allowed `PreToolUse` runs the call without a dialog.
+        permissionAllowSuppressesDialog: true,
         // Not audited. No captured copilot payload carries a `tool_use_id`, so
         // `'tool-call-id'` would be a guess; whether one exists is still to be
         // measured. Default = Claude's fallback, the time window.

package/dist/server/src/lib/hooks/sources/gemini/source.js

@@ -130,6 +130,8 @@ exports.geminiAgentEventSource = (0, define_source_1.definePushHookSource)({
         // Not audited. Default = Claude's current behaviour.
         sessionStartMayArriveLate: false,
         permissionReplyReleasesPrompt: false,
+        // Issue #3820: not measured, and no permission hook is registered.
+        permissionAllowSuppressesDialog: false,
         eventIdentity: null,
         resync: 'none',
         // Issue #2197. Nobody but the screen scraper records gemini replies.

package/dist/server/src/lib/hooks/sources/legacy-relay.js

@@ -65,6 +65,8 @@ function createLegacyRelaySource(cliToolId) {
             permissionHookPredictsDialog: false,
             sessionStartMayArriveLate: false,
             permissionReplyReleasesPrompt: false,
+            // Issue #3820: an unmeasured tool's allow is not assumed to answer a dialog.
+            permissionAllowSuppressesDialog: false,
             eventIdentity: null,
             resync: 'none',
             // Issue #2197. A tool on the compatibility relay has no reader, which

package/dist/server/src/lib/hooks/sources/opencode/ingest.js

@@ -81,6 +81,7 @@ const logger_1 = require("../../../../lib/logger");
 const agent_event_types_1 = require("../../../../lib/hooks/agent-event-types");
 const permission_adjudication_1 = require("../../../../lib/hooks/permission-adjudication");
 const pending_decision_kind_1 = require("../../../../lib/hooks/pending-decision-kind");
+const auto_yes_confirmation_ledger_1 = require("../../../../lib/polling/auto-yes-confirmation-ledger");
 const agent_event_state_1 = require("../../../../lib/session/agent-event-state");
 const structured_prompt_1 = require("../../../../lib/session/structured-prompt");
 const event_mapper_1 = require("../event-mapper");
@@ -362,6 +363,11 @@ async function ingestOpencodeEvent(target, event) {
             record.decisionId = (0, mappers_1.repliedPermissionId)(event.raw);
             record.promptSettled = replyReleasesPrompt(target, instanceId);
             (0, agent_event_state_1.recordAgentEvent)(target.worktreeId, tool_id_1.OPENCODE_CLI_TOOL_ID, instanceId, record, options);
+            // Issue #3820: the approval's confirmation in the Auto-Yes ledger ends
+            // here when Auto-Yes did not settle it — who answered is not known.
+            if (record.decisionId) {
+                (0, auto_yes_confirmation_ledger_1.noteLedgerApiDecisionReplied)({ worktreeId: target.worktreeId, cliToolId: tool_id_1.OPENCODE_CLI_TOOL_ID, instanceId }, record.decisionId);
+            }
             logger.info('opencode-permission-reply-observed', {
                 worktreeId: target.worktreeId,
                 instanceId,

package/dist/server/src/lib/hooks/sources/opencode/source.js

@@ -316,6 +316,8 @@ exports.opencodeAgentEventSource = (0, define_source_1.definePullEventSource)({
         // `permission.replied` arrives on the same stream and is a positive
         // statement that the dialog is gone (#1898). The only source that can say so.
         permissionReplyReleasesPrompt: true,
+        // Issue #3820: an allow is the approval itself, over the agent's API.
+        permissionAllowSuppressesDialog: true,
         // `per_...` — the id in the reply URL, which is the same id the frame
         // carries (#1899). Real identity, so this source does not need the time
         // window that loses the `stop` of a short turn.

package/dist/server/src/lib/hooks/sources/opencode-v2/history.js

@@ -367,9 +367,13 @@ async function writeOpencodeV2Turn(target, rendered, timestampMs) {
  * @param target - The instance the stream belongs to
  * @param port - Its server
  * @param sessionId - `ses_…` from the end-of-turn frame
+ * @param isCurrent - Whether the subscription that asked is still the
+ *   instance's (Issue #3733); checked after the read, right before the model
+ *   is latched. False skips only the latch: the rows are still written (the
+ *   turn did happen, and `requestId` keeps a later sync from doubling them)
  * @returns How many rows were written
  */
-function syncOpencodeV2History(target, port, sessionId) {
+function syncOpencodeV2History(target, port, sessionId, isCurrent = () => true) {
     return serialize((0, secrets_1.opencodeV2KeyOf)(target), async () => {
         const instanceId = target.instanceId ?? target.cliToolId;
         try {
@@ -395,7 +399,12 @@ function syncOpencodeV2History(target, port, sessionId) {
             }
             // Issue #2964: the model that answered, onto the hook latch the UI and
             // `capture --json` read. Before the rows, so a failed write cannot cost it.
-            (0, agent_event_state_1.recordAgentReportedModel)(target.worktreeId, tool_id_1.OPENCODE_V2_CLI_TOOL_ID, target.instanceId ?? tool_id_1.OPENCODE_V2_CLI_TOOL_ID, readLatestOpencodeV2AssistantModel(entries));
+            // Issue #3733: not for a subscription closed or replaced during the read —
+            // a restarted or stopped session would show the old model, and its change
+            // broadcast and Push (#2357) would fire for a session that is not there.
+            if (isCurrent()) {
+                (0, agent_event_state_1.recordAgentReportedModel)(target.worktreeId, tool_id_1.OPENCODE_V2_CLI_TOOL_ID, target.instanceId ?? tool_id_1.OPENCODE_V2_CLI_TOOL_ID, readLatestOpencodeV2AssistantModel(entries));
+            }
             const closed = buildOpencodeV2TurnsFromMessages(entries, sessionId).filter((turn) => turn.closed);
             const kept = closed.slice(-exports.MAX_OPENCODE_V2_SYNCED_TURNS);
             let written = 0;

package/dist/server/src/lib/hooks/sources/opencode-v2/ingest.js

@@ -64,6 +64,7 @@ const logger_1 = require("../../../../lib/logger");
 const agent_event_types_1 = require("../../../../lib/hooks/agent-event-types");
 const permission_adjudication_1 = require("../../../../lib/hooks/permission-adjudication");
 const pending_decision_kind_1 = require("../../../../lib/hooks/pending-decision-kind");
+const auto_yes_confirmation_ledger_1 = require("../../../../lib/polling/auto-yes-confirmation-ledger");
 const agent_event_state_1 = require("../../../../lib/session/agent-event-state");
 const structured_prompt_1 = require("../../../../lib/session/structured-prompt");
 const event_mapper_1 = require("../event-mapper");
@@ -207,6 +208,11 @@ async function ingestOpencodeV2Event(target, event, stopEffect = applyStop, load
             record.decisionId = (0, mappers_1.frameDecisionId)(event.raw);
             record.promptSettled = true;
             (0, agent_event_state_1.recordAgentEvent)(target.worktreeId, tool_id_1.OPENCODE_V2_CLI_TOOL_ID, instanceId, record, options);
+            // Issue #3820: as v1's `permission.replied` — the ledger's confirmation
+            // of this approval ends, by whoever answered it.
+            if (record.decisionId) {
+                (0, auto_yes_confirmation_ledger_1.noteLedgerApiDecisionReplied)({ worktreeId: target.worktreeId, cliToolId: tool_id_1.OPENCODE_V2_CLI_TOOL_ID, instanceId }, record.decisionId);
+            }
         }
         else if (event.event === 'notification' && event.detail === mappers_1.OPENCODE_V2_QUESTION_DETAIL) {
             const spec = await readQuestion(target, event, loadForm);

package/dist/server/src/lib/hooks/sources/opencode-v2/source.js

@@ -254,6 +254,8 @@ exports.opencodeV2AgentEventSource = (0, define_source_1.definePullEventSource)(
         permissionHookPredictsDialog: false,
         sessionStartMayArriveLate: false,
         permissionReplyReleasesPrompt: true,
+        // Issue #3820: an allow is the approval itself, over the agent's API.
+        permissionAllowSuppressesDialog: true,
         // Issue #2945: `per_…` / `frm_…`, the id the reply URL takes and the one
         // `permission.replied` / `form.replied` settle. Moves together with
         // `extractEventIdentity` below.

package/dist/server/src/lib/hooks/sources/opencode-v2/subscription.js

@@ -386,7 +386,7 @@ function deliver(state, frame) {
             error: error instanceof Error ? error.message : String(error),
         });
     }
-    void recordOpencodeV2TurnEnd(state.target, state.port, frame);
+    void recordOpencodeV2TurnEnd(state.target, state.port, frame, () => isCurrentSubscription(state));
     void refreshOpencodeV2UsageOnFrame(state.target, state.port, frame, () => isCurrentSubscription(state));
 }
 function isCurrentSubscription(state) {
@@ -429,16 +429,18 @@ function refreshOpencodeV2UsageOnFrame(target, port, frame, isCurrent = () => tr
  *
  * Exported for the tests, which drive frames through the path the stream does.
  *
+ * @param isCurrent - Handed to `syncOpencodeV2History`, which skips the model
+ *   latch when it is false after the read (Issue #3733)
  * @returns The sync, or null when the frame ends no turn
  */
-function recordOpencodeV2TurnEnd(target, port, frame) {
+function recordOpencodeV2TurnEnd(target, port, frame, isCurrent = () => true) {
     try {
         if (!(0, history_1.isOpencodeV2TurnEndEventType)((0, mappers_1.frameType)(frame)))
             return null;
         const sessionId = (0, mappers_1.frameSessionId)(frame);
         if (sessionId === null)
             return null;
-        return (0, history_1.syncOpencodeV2History)(target, port, sessionId);
+        return (0, history_1.syncOpencodeV2History)(target, port, sessionId, isCurrent);
     }
     catch (error) {
         logger.warn('opencode-v2-history-trigger-failed', {

package/dist/server/src/lib/hooks/sources/pending-decisions.js

@@ -124,12 +124,24 @@ function resetPendingDecisions() {
  * function exists, cannot find out without going out of its way — whether the
  * verdict left through the response body or through a second HTTP call.
  *
+ * @param options.onReceipt - Issue #3820: handed the receipt — what
+ *   {@link answerPendingDecisionWithReceipt} returns beside the body — before
+ *   the body is returned. For a caller that records the delivery (the hook
+ *   route's ledger) and writes the body whatever it says; the body is the same
+ *   with or without it.
  * @returns The body to write. `{}` means "nothing to say here", which for a
  *   hook is the measured no-decision reply and for a pull source is simply the
  *   ack of a request whose answer went elsewhere.
  */
-async function answerPendingDecision(source, ref, decision, verdict) {
-    return (await answerPendingDecisionWithReceipt(source, ref, decision, verdict)).body;
+async function answerPendingDecision(source, ref, decision, verdict, options = {}) {
+    const { body, delivery } = await answerPendingDecisionWithReceipt(source, ref, decision, verdict);
+    try {
+        options.onReceipt?.(delivery);
+    }
+    catch {
+        // The receipt is the caller's record, never a reason to lose the body.
+    }
+    return body;
 }
 /**
  * Answer one decision and keep the receipt (Issue #1898).

package/dist/server/src/lib/polling/antigravity-permission-receipts.js

@@ -24,7 +24,8 @@
  * ## What is kept
  *
  * ONE entry per instance: the tool name and the arrival time of the most recent
- * question. A second question replaces the first, because the only thing asked
+ * question, and the call it asked about (`callId`, Issue #3820) when the body
+ * named one. A second question replaces the first, because the only thing asked
  * of this record is "was there one lately".
  *
  * The screen carries no tool name (only the option labels), so the caller that
@@ -41,6 +42,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ANTIGRAVITY_PERMISSION_RECEIPT_WINDOW_MS = void 0;
 exports.recordAntigravityPermissionReceipt = recordAntigravityPermissionReceipt;
 exports.hasRecentAntigravityPermissionReceipt = hasRecentAntigravityPermissionReceipt;
+exports.getAntigravityPermissionReceiptAt = getAntigravityPermissionReceiptAt;
+exports.getAntigravityPermissionReceiptCallId = getAntigravityPermissionReceiptCallId;
 exports.resetAntigravityPermissionReceiptsForTests = resetAntigravityPermissionReceiptsForTests;
 const auto_yes_state_1 = require("../../lib/auto-yes-state");
 const global_state_1 = require("../global-state");
@@ -69,6 +72,12 @@ function pruneExpiredReceipts(now) {
             receipts.delete(key);
     }
 }
+/**
+ * Per-instance episode state of the poller's reads (Issue #3767); the logic is in
+ * `antigravity-receipt-episodes.ts`. The Map lives here only so that
+ * {@link resetAntigravityPermissionReceiptsForTests} empties both records.
+ */
+const observations = (0, global_state_1.getOrInitGlobal)('__antigravityReceiptObservations', () => new Map());
 /**
  * Record that agy asked CommandMate about a tool call.
  *
@@ -80,12 +89,14 @@ function pruneExpiredReceipts(now) {
  * @param instanceId - Agent instance id (the tool id itself for the primary)
  * @param toolName - Tool the request named, or null when the payload had none
  * @param at - Epoch ms the request arrived
+ * @param callId - Issue #3820: the call the request asked about
+ *   (`PermissionRequestPayload.callId`), null when it named none
  */
-function recordAntigravityPermissionReceipt(worktreeId, cliToolId, instanceId, toolName, at = Date.now()) {
+function recordAntigravityPermissionReceipt(worktreeId, cliToolId, instanceId, toolName, at = Date.now(), callId = null) {
     if (toolName === null)
         return;
     pruneExpiredReceipts(at);
-    receipts.set((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId), { toolName, at });
+    receipts.set((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId), { toolName, at, callId });
 }
 /**
  * Did agy ask CommandMate about a tool call, for this instance, within
@@ -107,7 +118,22 @@ function hasRecentAntigravityPermissionReceipt(worktreeId, cliToolId, instanceId
         return false;
     return now - receipt.at <= exports.ANTIGRAVITY_PERMISSION_RECEIPT_WINDOW_MS;
 }
+/**
+ * The latest question's arrival time for this instance, kept past the window
+ * (Issue #3767), or null when none was ever received.
+ */
+function getAntigravityPermissionReceiptAt(worktreeId, cliToolId, instanceId) {
+    return receipts.get((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId))?.at ?? null;
+}
+/**
+ * The call the latest question asked about (Issue #3820), or null when it
+ * named none or none was received. For the ledger only.
+ */
+function getAntigravityPermissionReceiptCallId(worktreeId, cliToolId, instanceId) {
+    return receipts.get((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId))?.callId ?? null;
+}
 /** Empty the record. Tests only: production entries age out on their own. */
 function resetAntigravityPermissionReceiptsForTests() {
     receipts.clear();
+    observations.clear();
 }

package/dist/server/src/lib/polling/antigravity-receipt-episodes.js

@@ -0,0 +1,301 @@
+"use strict";
+/**
+ * When did an agy approval dialog first appear, and was it asked about in time?
+ * (Issue #3767)
+ *
+ * `hasRecentAntigravityPermissionReceipt` measures the window to the CLOCK OF THE
+ * TICK. agy draws a dialog some seconds after the hook reply, and the poller ticks
+ * every 5s after a response, so a dialog drawn 5.9s after the receipt was first
+ * read 8.7s after it, outside the 8s window, and no later receipt came to open
+ * it. The gate here judges the window to the dialog's first appearance instead
+ * (bounded by the last read that saw no dialog), which the poller makes possible
+ * by bracketing its reads with {@link beginAntigravityFrameRead} /
+ * {@link endAntigravityFrameRead}. See `antigravity-permission-receipts` for the
+ * receipt record itself.
+ *
+ * @module lib/polling/antigravity-receipt-episodes
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ANTIGRAVITY_ANSWERED_DIALOG_GRACE_MS = exports.ANTIGRAVITY_PERMISSION_RECEIPT_OBSERVATION_SLACK_MS = void 0;
+exports.beginAntigravityFrameRead = beginAntigravityFrameRead;
+exports.endAntigravityFrameRead = endAntigravityFrameRead;
+exports.markAntigravityAnswerSent = markAntigravityAnswerSent;
+exports.getAntigravityAcceptedReceiptAt = getAntigravityAcceptedReceiptAt;
+exports.getAntigravityAcceptedReceiptCallId = getAntigravityAcceptedReceiptCallId;
+exports.getAntigravityReceiptVerdict = getAntigravityReceiptVerdict;
+exports.judgeAntigravityPermissionReceipt = judgeAntigravityPermissionReceipt;
+const auto_yes_state_1 = require("../../lib/auto-yes-state");
+const global_state_1 = require("../global-state");
+const antigravity_permission_receipts_1 = require("./antigravity-permission-receipts");
+/**
+ * Extra time past the window that the FIRST tick to see a dialog may be after
+ * the receipt (Issue #3767). The dialog's real appearance is only known to lie
+ * between the last tick that saw none and the first that saw it; that gap is a
+ * poll interval (5s after a response), so the window is judged on the lower
+ * bound and the first sighting is capped at window + this slack.
+ */
+exports.ANTIGRAVITY_PERMISSION_RECEIPT_OBSERVATION_SLACK_MS = 5_000;
+/**
+ * Longest gap between two poller reads over which an episode is carried
+ * (Issue #3767): the slowest tick (5s after a response) plus room for the
+ * capture. A longer gap (capture backoff, no session, Auto-Yes off and on) means
+ * nothing is known of the screen in between, so the episode is dropped and the
+ * next candidate is judged from its own first sighting.
+ */
+const MAX_READ_GAP_MS = exports.ANTIGRAVITY_PERMISSION_RECEIPT_OBSERVATION_SLACK_MS + 2_000;
+/**
+ * How long after the poller SENT its answer to an accepted dialog (Issue #3789,
+ * {@link markAntigravityAnswerSent}) a dialog may still be on screen before it
+ * is reported: the window, the slack, and the cooldown the poller waits after
+ * an answer. Until then it is agy taking its time to take the dialog down, and
+ * stays `answered` (silent). Past it the keys did not clear the dialog, or a
+ * dialog with no question of its own replaced it between two reads (the screen
+ * cannot tell which), and it is `outlived` — withheld, and recorded.
+ *
+ * Written as the sum's value (8s + 5s + 5s, `COOLDOWN_INTERVAL_MS`), not the
+ * sum: tests that mock the receipts module without the window constant would
+ * fail at load. A unit test pins it to the sum.
+ */
+exports.ANTIGRAVITY_ANSWERED_DIALOG_GRACE_MS = 18_000;
+/** Beyond this, a late dialog is read as "the hook stopped arriving" (#3767). */
+const RECEIPT_LAPSED_AFTER_MS = 60_000;
+const observations = (0, global_state_1.getOrInitGlobal)('__antigravityReceiptObservations', () => new Map());
+const isTimeOrNull = (x) => x === null || (typeof x === 'number' && Number.isFinite(x));
+/**
+ * The Map lives on globalThis and outlives a module reload, so an entry may have
+ * another shape. Such an entry is dropped (no episode: the plain tick test),
+ * never read as times — `undefined` would turn every comparison into NaN.
+ */
+function isObservation(v) {
+    if (typeof v !== 'object' || v === null)
+        return false;
+    const o = v;
+    return (typeof o.tracking === 'boolean' &&
+        typeof o.candidateSeen === 'boolean' &&
+        ['firstSeenAt', 'clearAt', 'prevReadAt', 'lastReadAt', 'acceptedReceiptAt', 'answerSentAt', 'usedReceiptAt'].every(k => isTimeOrNull(o[k])) &&
+        (o.verdict === null || typeof o.verdict === 'object') &&
+        (o.answerInterrupted === undefined || typeof o.answerInterrupted === 'boolean') &&
+        (o.acceptedCallId === undefined || o.acceptedCallId === null || typeof o.acceptedCallId === 'string'));
+}
+function existingObservation(key) {
+    const o = observations.get(key);
+    if (o === undefined)
+        return undefined;
+    if (isObservation(o))
+        return o;
+    observations.delete(key);
+    return undefined;
+}
+function observationOf(key) {
+    let o = existingObservation(key);
+    if (!o) {
+        o = {
+            tracking: false,
+            candidateSeen: false,
+            firstSeenAt: null,
+            clearAt: null,
+            prevReadAt: null,
+            lastReadAt: null,
+            acceptedReceiptAt: null,
+            acceptedCallId: null,
+            answerSentAt: null,
+            answerInterrupted: false,
+            usedReceiptAt: null,
+            verdict: null,
+        };
+        observations.set(key, o);
+    }
+    return o;
+}
+/**
+ * Start one poller read of an agy frame (Issue #3767). Pair with
+ * {@link endAntigravityFrameRead}; the pair is what lets the gate judge the
+ * window by when the dialog first appeared rather than by the tick's clock.
+ */
+function beginAntigravityFrameRead(worktreeId, instanceId, now = Date.now()) {
+    const o = observationOf((0, auto_yes_state_1.buildCompositeKey)(worktreeId, 'antigravity', instanceId));
+    if (o.lastReadAt !== null && !(now - o.lastReadAt <= MAX_READ_GAP_MS)) {
+        // Reads stopped for a while: the dialog now on screen may not be the one
+        // the episode saw, nor did it appear right after the last clear read.
+        o.firstSeenAt = null;
+        o.clearAt = null;
+        o.acceptedReceiptAt = null;
+        o.acceptedCallId = null;
+        o.answerSentAt = null;
+        o.answerInterrupted = false;
+        o.verdict = null;
+    }
+    o.tracking = true;
+    o.candidateSeen = false;
+    o.prevReadAt = o.lastReadAt;
+    o.lastReadAt = now;
+}
+/**
+ * End the read. A read in which the gate never saw a prompt candidate closes the
+ * episode: the next candidate is a new dialog with its own first sighting.
+ */
+function endAntigravityFrameRead(worktreeId, instanceId, now = Date.now()) {
+    const o = existingObservation((0, auto_yes_state_1.buildCompositeKey)(worktreeId, 'antigravity', instanceId));
+    if (!o || !o.tracking || o.candidateSeen)
+        return;
+    o.firstSeenAt = null;
+    o.acceptedReceiptAt = null;
+    o.acceptedCallId = null;
+    o.answerSentAt = null;
+    o.answerInterrupted = false;
+    o.verdict = null;
+    o.clearAt = now;
+}
+/**
+ * The poller sent keys to the dialog the current episode accepted (Issue #3789):
+ * starts {@link ANTIGRAVITY_ANSWERED_DIALOG_GRACE_MS}. Called only after the send
+ * reached tmux; a tick that accepted but sent nothing never calls it, so its
+ * dialog is never reported as one that outlived an answer. No-op without an
+ * accepted episode.
+ *
+ * Issue #3796: also called, with `interrupted`, when the send was cut short
+ * after it began (stopped part-way, or failed) — some of its keys may be on the
+ * pane, and the receipt is spent either way. Without it such a dialog stayed
+ * `answered` (silent) for as long as it stayed up. Starting the grace only
+ * leads to `outlived`, which withholds: nothing is answered because of it.
+ *
+ * @param options.forReceiptAt - The episode the send was for
+ *   ({@link getAntigravityAcceptedReceiptAt} read when it began). Given, only
+ *   that episode is marked: a send that comes back — whole or cut short —
+ *   after a stop → enable, when the successor already accepted a dialog on a
+ *   newer receipt, must not start that dialog's grace or give it its own
+ *   "cut short" (Issue #3796 review, review E for the whole send).
+ */
+function markAntigravityAnswerSent(worktreeId, instanceId, now = Date.now(), options = {}) {
+    const o = existingObservation((0, auto_yes_state_1.buildCompositeKey)(worktreeId, 'antigravity', instanceId));
+    if (!o || o.acceptedReceiptAt === null)
+        return;
+    if (options.forReceiptAt !== undefined && options.forReceiptAt !== o.acceptedReceiptAt)
+        return;
+    o.answerSentAt = now;
+    o.answerInterrupted = options.interrupted === true;
+}
+/**
+ * The receipt (`at`) the current episode was accepted on, or null when none
+ * (Issue #3796): what identifies the episode a send is for.
+ */
+function getAntigravityAcceptedReceiptAt(worktreeId, instanceId) {
+    return existingObservation((0, auto_yes_state_1.buildCompositeKey)(worktreeId, 'antigravity', instanceId))?.acceptedReceiptAt ?? null;
+}
+/**
+ * The call the current episode was accepted for (Issue #3820, design
+ * `docs/design/auto-yes-measurement-3820.md` §2.4): what the Auto-Yes ledger
+ * ties the screen's confirmation to, so the hook request and the `PostToolUse`
+ * of that call find it. Null when nothing is accepted or the receipt named no
+ * call. Read only to record; the gate never consults it.
+ */
+function getAntigravityAcceptedReceiptCallId(worktreeId, instanceId) {
+    const o = existingObservation((0, auto_yes_state_1.buildCompositeKey)(worktreeId, 'antigravity', instanceId));
+    if (!o || o.acceptedReceiptAt === null)
+        return null;
+    return o.acceptedCallId ?? null;
+}
+/**
+ * The verdict of the current episode's latest consultation, or null when no
+ * candidate dialog was read in the last tick (Issue #3767).
+ */
+function getAntigravityReceiptVerdict(worktreeId, instanceId) {
+    return existingObservation((0, auto_yes_state_1.buildCompositeKey)(worktreeId, 'antigravity', instanceId))?.verdict ?? null;
+}
+function causeFor(ageMs) {
+    if (ageMs === null)
+        return 'never';
+    return ageMs > RECEIPT_LAPSED_AFTER_MS ? 'lapsed' : 'late';
+}
+/**
+ * May the prompt candidate on this instance's frame be answered, judged by when
+ * the dialog first appeared (Issue #3767)?
+ *
+ * Replaces the tick-clock test of {@link hasRecentAntigravityPermissionReceipt}
+ * for the caller that answers: agy draws the dialog some seconds after the hook
+ * reply, and a 5s poll can first read it past the 8s window. The dialog is taken
+ * as appearing at the later of the last tick that saw none and the question's
+ * arrival. Still refused: a question that arrived after the dialog was already
+ * up, one older than the window by then, one already spent on another dialog,
+ * and none at all (a quotation follows no question).
+ *
+ * Without {@link beginAntigravityFrameRead} brackets there is no episode to
+ * remember, and this is exactly the old tick test.
+ */
+function judgeAntigravityPermissionReceipt(worktreeId, instanceId, nowOverride) {
+    const now = nowOverride ?? Date.now();
+    const key = (0, auto_yes_state_1.buildCompositeKey)(worktreeId, 'antigravity', instanceId);
+    const o = observationOf(key);
+    if (!o.tracking) {
+        // No bracketed reads: no episode to remember, the plain tick test.
+        const ok = nowOverride === undefined
+            ? (0, antigravity_permission_receipts_1.hasRecentAntigravityPermissionReceipt)(worktreeId, 'antigravity', instanceId)
+            : (0, antigravity_permission_receipts_1.hasRecentAntigravityPermissionReceipt)(worktreeId, 'antigravity', instanceId, undefined, nowOverride);
+        return { ok, cause: ok ? null : 'never', lastReceiptAt: null, firstSeenAt: now, ageMs: null };
+    }
+    const lastReceiptAt = (0, antigravity_permission_receipts_1.getAntigravityPermissionReceiptAt)(worktreeId, 'antigravity', instanceId);
+    const sameRead = o.candidateSeen;
+    o.candidateSeen = true;
+    if (o.firstSeenAt === null)
+        o.firstSeenAt = now;
+    const firstSeenAt = o.firstSeenAt;
+    const ageMs = lastReceiptAt === null ? null : firstSeenAt - lastReceiptAt;
+    const verdict = (cause, age = ageMs) => {
+        const v = { ok: cause === null, cause, lastReceiptAt, firstSeenAt, ageMs: age };
+        o.verdict = v;
+        return v;
+    };
+    if (lastReceiptAt === null)
+        return verdict('never');
+    if (o.acceptedReceiptAt !== null && lastReceiptAt > o.acceptedReceiptAt) {
+        // A newer question while the answered dialog stayed up on every tick: the
+        // dialog it asked about replaced the old one between two reads. A new
+        // episode, which cannot have appeared before the previous read.
+        o.firstSeenAt = now;
+        o.clearAt = o.prevReadAt;
+        o.acceptedReceiptAt = null;
+        o.acceptedCallId = null;
+        o.answerSentAt = null;
+        o.answerInterrupted = false;
+        return judgeAntigravityPermissionReceipt(worktreeId, instanceId, now);
+    }
+    if (o.acceptedReceiptAt === lastReceiptAt) {
+        // The read that accepted may consult the gate twice (the tool's reader, then
+        // the generic pass). A LATER tick over the same dialog is the old tick test:
+        // a dialog that outlives the answer is not answered again past the window.
+        // Withheld, but as `answered`: the caller records no no-hook-receipt for it.
+        if (sameRead || now - lastReceiptAt <= antigravity_permission_receipts_1.ANTIGRAVITY_PERMISSION_RECEIPT_WINDOW_MS)
+            return verdict(null);
+        // Issue #3789: not forever, though, once keys were sent. Past the grace they
+        // did not clear the dialog (or one with no question of its own replaced it),
+        // and staying silent would leave the session stopped with no record of why.
+        // Accepted but never sent stays `answered`: the poller's own reason for not
+        // sending (partial-answer, …) is the one to keep, not overwrite. Written as
+        // `!(… <= …)` so that a NaN time reports.
+        if (o.answerSentAt !== null && !(now - o.answerSentAt <= exports.ANTIGRAVITY_ANSWERED_DIALOG_GRACE_MS)) {
+            const v = verdict('outlived');
+            if (o.answerInterrupted === true)
+                v.answerInterrupted = true;
+            return v;
+        }
+        return verdict('answered');
+    }
+    if (o.usedReceiptAt === lastReceiptAt)
+        return verdict('used');
+    if (lastReceiptAt > firstSeenAt)
+        return verdict('predates');
+    // The clear read bounds the appearance only when it is the read right before
+    // the first sighting; otherwise the dialog may have been up since long before.
+    const clearBound = o.clearAt !== null && firstSeenAt - o.clearAt <= MAX_READ_GAP_MS ? o.clearAt : firstSeenAt;
+    const appearedAfter = Math.max(clearBound, lastReceiptAt);
+    // Written as `!(… <= …)` so that a NaN withholds.
+    if (!(appearedAfter - lastReceiptAt <= antigravity_permission_receipts_1.ANTIGRAVITY_PERMISSION_RECEIPT_WINDOW_MS) ||
+        !(firstSeenAt - lastReceiptAt <=
+            antigravity_permission_receipts_1.ANTIGRAVITY_PERMISSION_RECEIPT_WINDOW_MS + exports.ANTIGRAVITY_PERMISSION_RECEIPT_OBSERVATION_SLACK_MS)) {
+        return verdict(causeFor(ageMs));
+    }
+    o.acceptedReceiptAt = lastReceiptAt;
+    o.acceptedCallId = (0, antigravity_permission_receipts_1.getAntigravityPermissionReceiptCallId)(worktreeId, 'antigravity', instanceId);
+    o.usedReceiptAt = lastReceiptAt;
+    return verdict(null);
+}

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

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * The `AskUserQuestion` confirm pages Auto-Yes leaves to a human (Issue #3497,
+ * Issue #3748).
+ *
+ * `Submit` on these pages picks nothing: it commits whatever stands as the
+ * answers. On Kewton/Musunest#283 that was the worker's own proposal, which the
+ * worker then implemented as though a human had approved it. So neither the
+ * server's poller (`suppressIfNotOursToAnswer`, step 3.3) nor the browser's
+ * fallback (`useAutoYes`, which answers only while no server poller runs) sends
+ * a key to them.
+ *
+ * Server-only: `normalizeFrame` and the tools' detectors reach `logger` → `env`
+ * → `fs`. The browser judges by the prompt's options instead
+ * (`polling/auto-yes-confirm-shape`).
+ *
+ * @module lib/polling/auto-yes-confirm-page
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAutoYesDeclinedConfirmPage = isAutoYesDeclinedConfirmPage;
+exports.isAutoYesDeclinedConfirmFrame = isAutoYesDeclinedConfirmFrame;
+const frame_1 = require("../detection/tools/frame");
+const selection_shape_1 = require("../detection/tools/command-code/selection-shape");
+const detect_1 = require("../detection/tools/claude/detect");
+/**
+ * Is this frame one of the confirm pages Auto-Yes does not answer?
+ *
+ * - `command-code`: `❯ 1. Submit` / `2. Cancel` under the question's tab strip,
+ *   with or without the back hint (#3497, `isCommandCodeQuestionConfirmPage`).
+ * - `claude`: `Ready to submit your answers?` / `❯ 1. Submit answers` /
+ *   `2. Cancel` (#3748, `isClaudeAskUserQuestionConfirmPage`).
+ *
+ * Every other tool: false — none has a measured confirm page.
+ *
+ * @param frame - The tick's one normalised frame (Issue #3183)
+ */
+function isAutoYesDeclinedConfirmPage(cliToolId, frame) {
+    // An empty capture draws no page (and Claude's reading walks the rows).
+    if (!frame.raw)
+        return false;
+    if (cliToolId === 'command-code')
+        return (0, selection_shape_1.isCommandCodeQuestionConfirmPage)(frame.raw);
+    if (cliToolId === 'claude')
+        return (0, detect_1.isClaudeAskUserQuestionConfirmPage)(frame);
+    return false;
+}
+/**
+ * {@link isAutoYesDeclinedConfirmPage} on a capture as text. False for no frame.
+ */
+function isAutoYesDeclinedConfirmFrame(cliToolId, output) {
+    if (!output)
+        return false;
+    if (cliToolId !== 'command-code' && cliToolId !== 'claude')
+        return false;
+    return isAutoYesDeclinedConfirmPage(cliToolId, (0, frame_1.normalizeFrame)(output, cliToolId));
+}