commandmate 0.46.1 → 0.47.2

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

@@ -0,0 +1,287 @@
+"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 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
+ * @param readWithoutGate - The same frame read without `receiptScope`
+ * @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) {
+    // 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;
+    // 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);
+    // 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: resolution.suppressedBy === auto_yes_suppression_reason_1.POLICY_LOOKUP_FAILED_SUPPRESSION_REASON
+                ? '契約の照会に失敗したので答えていない。サーバーログの policy-lookup-failed を確認'
+                : '契約の autoYes が答えを止めている。契約の autoYes を確認',
+        });
+        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);
+}
+/**
+ * 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.
+        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）を確認';
+    }
+}

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

@@ -9,6 +9,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.promptFrameKey = promptFrameKey;
 exports.warnOncePerFrame = warnOncePerFrame;
 exports.partialAnswerScreenKey = partialAnswerScreenKey;
+exports.ledgerScreenKey = ledgerScreenKey;
 exports.getPartialAnswer = getPartialAnswer;
 exports.forgetPartialAnswer = forgetPartialAnswer;
 exports.forgetPartialAnswersByWorktree = forgetPartialAnswersByWorktree;
@@ -22,6 +23,7 @@ const logger_1 = require("../../lib/logger");
 const auto_yes_state_1 = require("../auto-yes-state");
 const global_state_1 = require("../global-state");
 const auto_yes_enter_fallback_state_1 = require("./auto-yes-enter-fallback-state");
+const appearance_1 = require("../prompt-observation/appearance");
 const logger = (0, logger_1.createLogger)('auto-yes-poller');
 /**
  * Issue #2995: what makes two ticks "the same prompt" for `warnOncePerFrame`.
@@ -74,15 +76,77 @@ function partialAnswerScreenKey(promptData) {
     const options = promptData.type === 'multiple_choice'
         ? promptData.options.map((o) => `${o.number}.${o.label}`).join('\n')
         : promptData.options.join('\n');
-    return [(0, prompt_key_1.generatePromptKey)(promptData), options, withoutCursorMarks(promptData.approvalTarget ?? '')].join('\u0000');
+    return [(0, prompt_key_1.generatePromptKey)(promptData), options, withoutCursorMarks(promptData)].join('\u0000');
 }
 /**
  * `approvalTarget` with the cursor taken out: the generic parser copies the
  * option panel into it, `❯` row included, so a moved cursor would otherwise
- * read as another prompt. Leading indentation goes too — the cursor row is the
- * one indented differently.
+ * read as another prompt.
+ *
+ * [Issue #3817] Only the rows the block reader adopted as the options are
+ * aligned (`approvalTargetWithOptionRowsAligned`, the reading #3812 gives the
+ * strict respond), so two commands whose bodies differ by an indent or a `>`
+ * are two screens. A label the block reader read may run longer than the
+ * prompt's — it folds wrapped rows and the footer in — so it only has to start
+ * with it. A yes/no prompt has no cursor and is read as it is. A list whose
+ * rows cannot be told that way keeps the old reading below: two bodies then
+ * read as one screen, which holds the prompt for a human rather than typing
+ * the answer twice.
+ */
+function withoutCursorMarks(promptData) {
+    const target = promptData.approvalTarget ?? '';
+    if (promptData.type !== 'multiple_choice')
+        return target;
+    const aligned = (0, appearance_1.approvalTargetWithOptionRowsAligned)(target, promptData.options.map((o) => o.label), (read, named) => read.startsWith(named));
+    return aligned ?? withoutLeadingMarks(target);
+}
+/**
+ * Which confirmation the ledger counts a prompt as (Issue #3820): the
+ * {@link partialAnswerScreenKey} reading where the option rows can be told,
+ * and otherwise one that still keeps the body. That key's fallback takes the
+ * marks and indent off every row — for a partial answer, two bodies reading as
+ * one screen holds the prompt for a human, the safe side — but for counting it
+ * makes two confirmations whose commands differ by a `>` or an indent one.
+ * Here only the rows that ARE the options the reader read — the row's number
+ * and label match one of `promptData.options` — lose their gutter (where the
+ * cursor sits); every other row, a numbered line of the body included, stays
+ * byte for byte. The match takes the separator as the readers do: `1.`, `1)`
+ * or a bare `1` followed by any run of spaces (`❯ 1  Yes`).
  */
-function withoutCursorMarks(text) {
+function ledgerScreenKey(promptData) {
+    if (promptData.type !== 'multiple_choice')
+        return partialAnswerScreenKey(promptData);
+    const target = promptData.approvalTarget ?? '';
+    const aligned = (0, appearance_1.approvalTargetWithOptionRowsAligned)(target, promptData.options.map((o) => o.label), (read, named) => read.startsWith(named));
+    if (aligned !== null)
+        return partialAnswerScreenKey(promptData);
+    const options = promptData.options.map((o) => `${o.number}.${o.label}`).join('\n');
+    return [(0, prompt_key_1.generatePromptKey)(promptData), options, withOptionRowGuttersAligned(target, promptData.options)].join('\u0000');
+}
+/** A row's leading cursor marks and indentation. */
+const LEADING_MARKS_PATTERN = /^[\s\u276F\u203A>\u25B6\u25BA\u25CF\u25CB\u25C9\u2192]+/u;
+/** A row's option number and the text after its separator (`1.`, `1)` or `1`, then spaces). */
+const OPTION_ROW_PATTERN = /^(\d+)(?:[.)]\s*|\s+)(.*)$/u;
+const collapseSpaces = (text) => text.replace(/\s+/gu, ' ').trim();
+/** Rows that match one of `options` lose their leading marks and indent; the rest stay. */
+function withOptionRowGuttersAligned(text, options) {
+    return text
+        .split('\n')
+        .map((line) => {
+        const row = OPTION_ROW_PATTERN.exec(line.replace(LEADING_MARKS_PATTERN, ''));
+        if (row === null)
+            return line;
+        const rest = collapseSpaces(row[2]);
+        const isOption = options.some((option) => {
+            const label = collapseSpaces(option.label);
+            return option.number === Number(row[1]) && label !== '' && rest.startsWith(label);
+        });
+        return isOption ? line.replace(LEADING_MARKS_PATTERN, '') : line;
+    })
+        .join('\n');
+}
+/** Every row's leading marks and indentation taken out (the reading before #3817). */
+function withoutLeadingMarks(text) {
     return text
         .split('\n')
         .map((line) => line.replace(/^[\s\u276F\u203A>\u25B6\u25BA\u25CF\u25CB\u25C9\u2192]+/u, ''))
@@ -158,8 +222,12 @@ function clearPartialAnswers() {
 /** The sends in flight. globalThis for hot reload (#153), like the Map above. */
 const sendAttempts = (0, global_state_1.getOrInitGlobal)('__autoYesSendAttempts', () => new Set());
 const sendAttemptSeq = (0, global_state_1.getOrInitGlobal)('__autoYesSendAttemptSeq', () => ({ last: 0 }));
-/** Register a send about to start (the poller, before `sendPromptAnswer`). */
-function beginSendAttempt(compositeKey, screenKey, epoch) {
+/**
+ * Register a send about to start (the poller, before `sendPromptAnswer`).
+ *
+ * @param ledger - Issue #3820: the ledger's handle for this send, if any
+ */
+function beginSendAttempt(compositeKey, screenKey, epoch, ledger = null) {
     const attempt = {
         seq: ++sendAttemptSeq.last,
         screenKey,
@@ -167,6 +235,7 @@ function beginSendAttempt(compositeKey, screenKey, epoch) {
         recordEpoch: epoch,
         moved: false,
         state: 'pending',
+        ledger,
     };
     sendAttempts.add(attempt);
     return attempt;

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

@@ -0,0 +1,109 @@
+"use strict";
+/**
+ * Auto-Yes poller: synchronous steps of `detectAndRespondToPrompt` that decide
+ * whether a read prompt is left alone (Issue #3781) (Issue #3783: split out of
+ * `auto-yes-poller.ts`).
+ *
+ * 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-steps
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withheldForEarlierSend = withheldForEarlierSend;
+exports.resolveAnswerUnderPolicy = resolveAnswerUnderPolicy;
+exports.skippedForUnownedSession = skippedForUnownedSession;
+const auto_yes_resolver_1 = require("./auto-yes-resolver");
+const auto_yes_policy_1 = require("./auto-yes-policy");
+const auto_yes_suppression_reason_1 = require("./auto-yes-suppression-reason");
+const auto_yes_poller_state_1 = require("./auto-yes-poller-state");
+const auto_yes_prompt_suppression_1 = require("./auto-yes-prompt-suppression");
+const auto_yes_confirmation_ledger_1 = require("./auto-yes-confirmation-ledger");
+/**
+ * Step 2.5 of `detectAndRespondToPrompt`: whether an earlier send to this
+ * screen keeps the prompt from being answered now.
+ *
+ * @returns true when the prompt is withheld (the caller returns `no_answer`)
+ */
+function withheldForEarlierSend(judged, screenKey, epoch) {
+    const { worktreeId, cliToolId, instanceId, compositeKey, pollerState, promptData, frameKey } = judged;
+    const partial = (0, auto_yes_poller_state_1.getPartialAnswer)(compositeKey, epoch);
+    if (partial !== null) {
+        if (partial.screenKey === screenKey) {
+            (0, auto_yes_prompt_suppression_1.suppressAndWarnOnce)(judged, {
+                reason: auto_yes_suppression_reason_1.PARTIAL_ANSWER_SUPPRESSION_REASON,
+                mode: null,
+                promptType: promptData.type,
+            }, `${frameKey}\u0000partial-answer`, 'poller:auto-yes-skipped-partial-answer', { promptType: promptData.type, stoppedAt: partial.at });
+            return true;
+        }
+        // Another prompt is on screen: only the sends at the forgotten one's
+        // screen go with it (#3713) — one in flight at this screen keeps its hold.
+        (0, auto_yes_poller_state_1.forgetPartialAnswer)(compositeKey, partial.screenKey);
+    }
+    // Issue #3713: a worktree ID move carried an answer still being sent to
+    // this session's key. Its keys may already be on the pane, and how its send
+    // ends is not known yet — so this screen gets no keys until it comes back
+    // (recorded as a partial answer above, or gone).
+    if ((0, auto_yes_poller_state_1.hasMovedSendInFlight)(compositeKey, epoch, screenKey)) {
+        // Issue #3820: a stop the policy record never carries — the ledger's own reason.
+        (0, auto_yes_confirmation_ledger_1.withholdLedgerConfirmation)(judged, 'moved-send-in-flight');
+        (0, auto_yes_poller_state_1.warnOncePerFrame)(pollerState, `${frameKey}\u0000moved-send-in-flight`, 'poller:auto-yes-skipped-moved-send-in-flight', { worktreeId, cliToolId, instanceId, promptType: promptData.type });
+        return true;
+    }
+    return false;
+}
+/**
+ * Step 4 of `detectAndRespondToPrompt`: the auto answer under the execution
+ * contract's policy, recording the suppression when the policy withholds it.
+ *
+ * @returns The answer to send, or null when there is none
+ */
+function resolveAnswerUnderPolicy(judged) {
+    const { worktreeId, cliToolId, instanceId, promptData, frameKey } = judged;
+    // Issue #3822: a failed lookup reaches the resolver as unknown and withholds.
+    const policy = (0, auto_yes_policy_1.getSessionAutoYesPolicy)(worktreeId, cliToolId, instanceId);
+    const resolution = (0, auto_yes_resolver_1.resolveAutoAnswerWithPolicy)(promptData, policy);
+    if (resolution.suppressedBy) {
+        const mode = (0, auto_yes_resolver_1.policyLookupMode)(policy);
+        // Issue #1684: the log line alone leaves a CLI-driven pipeline blind to
+        // why its worker stalled. Record the suppression so buildCurrentOutput
+        // can publish it (`autoYes.lastSuppression` in capture --json).
+        (0, auto_yes_prompt_suppression_1.suppressAndWarnOnce)(judged, {
+            reason: resolution.suppressedBy,
+            mode,
+            promptType: promptData.type,
+            pattern: resolution.pattern,
+        }, `${frameKey}\u0000${resolution.suppressedBy}\u0000${mode ?? ''}\u0000${resolution.pattern ?? ''}`, 'poller:auto-yes-suppressed-by-policy', {
+            reason: resolution.suppressedBy,
+            mode,
+            pattern: resolution.pattern,
+            promptType: promptData.type,
+        });
+    }
+    return resolution.answer;
+}
+/**
+ * Issue #2865: whether the session is not this server's to type into (another
+ * server created it, or the worktree is gone), warning once per frame.
+ *
+ * @returns true when the caller returns `no_answer`
+ */
+function skippedForUnownedSession(judged, sessionName, ownership) {
+    const { worktreeId, cliToolId, instanceId, pollerState, frameKey } = judged;
+    if (ownership === null || ownership.verdict === 'foreign') {
+        // Issue #3820: as above, the ledger's own reason.
+        (0, auto_yes_confirmation_ledger_1.withholdLedgerConfirmation)(judged, 'foreign-session');
+        (0, auto_yes_poller_state_1.warnOncePerFrame)(pollerState, `${frameKey}\u0000${sessionName}\u0000${ownership ? 'foreign' : 'worktree_not_found'}`, 'poller:auto-yes-skipped-foreign-session', {
+            worktreeId,
+            cliToolId,
+            instanceId,
+            sessionName,
+            sessionPath: ownership?.sessionPath ?? null,
+            reason: ownership ? 'foreign' : 'worktree_not_found',
+        });
+        return true;
+    }
+    return false;
+}

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;
+}