commandmate 0.46.0 → 0.47.0

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

@@ -0,0 +1,281 @@
+"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.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'));
+}
+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,
+            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.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.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 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.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.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));
+}

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

@@ -392,10 +392,17 @@ function assessPromptAnswerability(cliToolId, frame) {
             },
         };
     }
+    // Issue #3808: a numbered agy screen agy's reader declines (the login-method
+    // screen, a permission dialog whose `tab Amend` footer is cut or off the
+    // pane) is no prompt — not the generic parser's reading of its `1. / 2.` rows.
+    const declinedAgyScreen = cliToolId === 'antigravity' && toolDialog === null
+        && (0, dialog_1.isAntigravityUnvouchedNumberedScreen)(cleanOutput);
     const isCommandCodeQuestion = commandCodeQuestion.kind === 'prompt';
     const candidate = (commandCodeQuestion.kind === 'prompt' ? commandCodeQuestion.prompt : null)
         ?? toolDialog
-        ?? (0, prompt_detector_1.detectPrompt)(cleanOutput, (0, cli_patterns_1.buildDetectPromptOptions)(cliToolId));
+        ?? (declinedAgyScreen
+            ? { isPrompt: false, cleanContent: cleanOutput }
+            : (0, prompt_detector_1.detectPrompt)(cleanOutput, (0, cli_patterns_1.buildDetectPromptOptions)(cliToolId)));
     // Issue #3183: one frame, normalised once from the capture, for the
     // quotation veto and the presence gate alike — the reading the status chain
     // and the Auto-Yes poller apply, so Send is offered exactly when they agree.

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

@@ -52,15 +52,29 @@ const lastEnterFallbacks = (0, global_state_1.getOrInitGlobal)('__autoYesEnterFa
 /**
  * Record that Auto-Yes sent its Enter to a screen.
  *
+ * Issue #3706: `sent.epoch` is the session epoch the Enter was decided for. The
+ * Enter's `send-keys` is awaited, and a new session begun meanwhile has already
+ * dropped the record ({@link beginEnterFallbackSession}); the old send coming
+ * back must not put one back about the new process. So a record whose epoch is
+ * no longer the current one is not written. Omitted, the current epoch is used.
+ *
  * @param at - Epoch ms; defaults to now. Overridable so tests are deterministic.
+ * @returns Whether the record was written
  */
 function recordEnterFallbackSent(worktreeId, cliToolId, instanceId, sent, at = Date.now()) {
-    lastEnterFallbacks.set((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId), {
+    const key = (0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId);
+    const current = getEnterFallbackSessionEpoch(key);
+    const { epoch = current, ...rest } = sent;
+    if (epoch !== current)
+        return false;
+    lastEnterFallbacks.set(key, {
         outcome: 'sent',
-        ...sent,
+        ...rest,
         sentAt: at,
         at,
+        epoch,
     });
+    return true;
 }
 /**
  * Record that the screen the last Enter went to is still up. A no-op when there
@@ -77,7 +91,12 @@ function recordEnterFallbackNoEffect(worktreeId, cliToolId, instanceId, screenKe
 }
 /** @returns The last Enter for this session, or null when Auto-Yes never sent one. */
 function getLastEnterFallback(worktreeId, cliToolId, instanceId) {
-    return lastEnterFallbacks.get((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId)) ?? null;
+    const key = (0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId);
+    const record = lastEnterFallbacks.get(key);
+    // Issue #3706: a record of an earlier session says nothing about this one.
+    if (!record || record.epoch !== getEnterFallbackSessionEpoch(key))
+        return null;
+    return record;
 }
 /**
  * The record as published, judged against the prompt the payload carries.

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