commandmate 0.47.2 → 0.49.0

package/dist/server/src/lib/detection/tools/command-code/dialog.js

@@ -78,6 +78,7 @@ const ansi_1 = require("../../ansi");
 const prompt_detect_multiple_choice_1 = require("../../prompt-detect-multiple-choice");
 const selection_shape_1 = require("../../selection-shape");
 const dialog_block_1 = require("../dialog-block");
+const option_recommendation_1 = require("../../option-recommendation");
 const truncate_raw_content_1 = require("../../truncate-raw-content");
 /**
  * How many rows of dialog this reader will parse.
@@ -354,6 +355,8 @@ function readCommandCodeQuestionDialog(frame) {
         region,
         prompt: {
             ...built,
+            // Issue #3863: beside the payload, never in it — see `PromptDetectionResult`.
+            optionRecommendations: readCommandCodeOptionRecommendations(lines, regionRows.slice(block.firstRow), labels.length),
             promptData: {
                 ...promptData,
                 // Only ever added, never set to `false`: see the `checked` note above.
@@ -373,6 +376,70 @@ function readCommandCodeQuestionDialog(frame) {
         },
     };
 }
+/** The option row's own prefix — indent, gutter, cursor and number — up to where its label starts. */
+const OPTION_ROW_PREFIX_PATTERN = /^[^\S\n]*[│┃]?[^\S\n]*[❯›●>]?[^\S\n]*\d{1,2}[.)][^\S\n]+/;
+/**
+ * What each option's title says about being recommended (Issue #3863,
+ * `option-recommendation`), read off the option rows again — the block reader
+ * joins everything under an option into its label, and this screen says
+ * which rows are the title.
+ *
+ * Measured on the reported capture (#2521, 1.53.0): an option's description
+ * starts on its own row at the option's LABEL column (`❯ 1. ` → five spaces),
+ * and only what the pane wraps lands further left (column 0 or 1). So under an
+ * option row:
+ *
+ * - a row at or right of the label column starts the description, and
+ *   everything after it is description;
+ * - a row left of it, before any description, is the title wrapping — unless
+ *   the row above could not have wrapped into it (its first word would have
+ *   fit there, `cannotBeWrapOf`), in which case it is a description drawn
+ *   further left (the synthetic indent 0 / 1 / 2 shapes #2522 reads), and the
+ *   rest is description too;
+ * - `Submit` / `Next` and the hint bar under the last option are nobody's.
+ *
+ * Every option `'unknown'` when the walk does not find the same options the
+ * reading did.
+ *
+ * @param frameRows - Every row of the capture, for the pane's width
+ * @param optionRows - The region's rows from option 1's row on
+ * @param optionCount - How many options the reading found
+ */
+function readCommandCodeOptionRecommendations(frameRows, optionRows, optionCount) {
+    const paneColumns = (0, option_recommendation_1.lowerBoundPaneColumns)(frameRows);
+    const titles = [];
+    let labelColumn = 0;
+    let lastTitleRow = '';
+    let inDescription = false;
+    for (const row of optionRows) {
+        if (row.trim() === '')
+            continue;
+        const parsed = (0, dialog_block_1.parseNumberedOptionRow)(row);
+        if (parsed !== null && parsed.number === titles.length + 1) {
+            titles.push([parsed.label]);
+            labelColumn = OPTION_ROW_PREFIX_PATTERN.exec(row)?.[0].length ?? 0;
+            lastTitleRow = row;
+            inDescription = false;
+            continue;
+        }
+        if (titles.length === 0)
+            break;
+        if (COMMAND_CODE_CONFIRM_ROW_PATTERN.test(row) || COMMAND_CODE_QUESTION_HINT_BAR_PATTERN.test(row))
+            continue;
+        if (inDescription)
+            continue;
+        const indent = row.length - row.trimStart().length;
+        if (indent >= labelColumn || (0, option_recommendation_1.cannotBeWrapOf)(lastTitleRow, row, paneColumns)) {
+            inDescription = true;
+            continue;
+        }
+        titles[titles.length - 1].push(row.trim());
+        lastTitleRow = row;
+    }
+    if (titles.length !== optionCount)
+        return Array.from({ length: optionCount }, () => 'unknown');
+    return titles.map((rows) => (0, option_recommendation_1.isRecommendedTitle)(rows.join(' ')));
+}
 /**
  * The same reading as a `PromptDetectionResult | null`, for the call sites whose
  * only question is "is there an answerable prompt here?".

package/dist/server/src/lib/detection/tools/dialog-block.js

@@ -30,7 +30,9 @@
  * glyph or an SGR attribute, so both spellings parse to the same block.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNumberedOptionRow = parseNumberedOptionRow;
 exports.findNumberedOptionBlock = findNumberedOptionBlock;
+const option_recommendation_1 = require("../option-recommendation");
 /**
  * One numbered option row.
  *
@@ -58,6 +60,16 @@ const OPTION_ROW_PATTERN = /^[^\S\n]*[│┃]?[^\S\n]*([❯›●>])?[^\S\n]*(\d
 const DEFAULT_FOOTER_SCAN_ROWS = 8;
 /** How many rows one option block may span, wrapped continuations included. */
 const MAX_BLOCK_ROWS = 60;
+/**
+ * Read one row as a numbered option row (`❯ 1. label`), or null.
+ *
+ * Exported for a tool module that walks the block's rows again to tell an
+ * option's title from its description (Issue #3863), so it reads an option
+ * row exactly as this reader does.
+ */
+function parseNumberedOptionRow(row) {
+    return parseOptionRow(row);
+}
 function parseOptionRow(row) {
     const match = OPTION_ROW_PATTERN.exec(row);
     if (!match)
@@ -117,6 +129,8 @@ function findNumberedOptionBlock(lines, endExclusive, footerScanRows = DEFAULT_F
     const lastRow = cursor;
     // 2. Walk up the run, collecting each option and any wrapped rows above it.
     const collected = [bottom];
+    // Issue #3863: whether rows were folded into each collected option's label.
+    const folded = [false];
     let expected = bottom.number - 1;
     let row = cursor - 1;
     let spanned = 1;
@@ -135,6 +149,7 @@ function findNumberedOptionBlock(lines, endExclusive, footerScanRows = DEFAULT_F
         const parsed = parseOptionRow(text);
         if (parsed && parsed.number === expected) {
             collected.unshift({ ...parsed, label: [parsed.label, ...pending].join(' ').trim() });
+            folded.unshift(pending.length > 0);
             pending = [];
             expected--;
             row--;
@@ -155,5 +170,6 @@ function findNumberedOptionBlock(lines, endExclusive, footerScanRows = DEFAULT_F
         firstRow: row + 1,
         lastRow,
         footer: footerRows.join('\n'),
+        optionRecommendations: collected.map((option, index) => folded[index] ? 'unknown' : (0, option_recommendation_1.isRecommendedTitle)(option.label)),
     };
 }

package/dist/server/src/lib/detection/upstream-faults.js

@@ -54,6 +54,22 @@ exports.UPSTREAM_FAULTS = [
         pattern: /\bmaximum context length is \d+ tokens\b/i,
         selfRetrying: false,
     },
+    {
+        // codex ends the turn with `Selected model is at capacity` and does not
+        // answer (Issue #3936); the same model will not, so the cue is to switch
+        // instance or model. Anchored on the sentence, not on "at capacity": the
+        // 529 line above says "The API is at capacity" and is `overloaded`.
+        //
+        // And on codex's own error row, not on the sentence alone: `■ ` at column
+        // 0, the shape codex 0.160.0 draws its errors in (measured on
+        // `■ Conversation interrupted`). A reply that names or quotes the error —
+        // this Issue, its review — is indented (`• ` / `  `), and an input echo
+        // starts with `› `; matching those would fail a healthy turn with exit 11.
+        // The capacity row itself is unmeasured (the fixture is synthetic).
+        id: 'model-capacity',
+        pattern: /^■ Selected model is at capacity\b/im,
+        selfRetrying: false,
+    },
     { id: 'limit-reached', pattern: /\blimit reached\b/i, selfRetrying: false },
     { id: 'api-error', pattern: /\bAPI Error(?::|\s+\d{3})/i, selfRetrying: false },
 ];
@@ -90,8 +106,9 @@ function matchUpstreamFault(frame) {
     const clean = (0, ansi_1.stripAnsi)(frame);
     for (const fault of exports.UPSTREAM_FAULTS) {
         const match = fault.pattern.exec(clean);
-        // The patterns are unanchored and stateless (no /g), so `exec` cannot carry
-        // a lastIndex between calls — but reading `index` requires exec regardless.
+        // The patterns are stateless (no /g; only `model-capacity` is anchored, to a
+        // line start with /m), so `exec` cannot carry a lastIndex between calls —
+        // but reading `index` requires exec regardless.
         if (!match)
             continue;
         const lineStart = clean.lastIndexOf('\n', match.index) + 1;

package/dist/server/src/lib/detection/waiting-screen-reading.js

@@ -0,0 +1,98 @@
+"use strict";
+/**
+ * One reading of a frame for the waiting episodes (Issue #3798, design §2.2 /
+ * 規則 1 / I9).
+ *
+ * Three observers read a frame and tell the episode store about it: the status
+ * probe (`worktree-status-helper`), the response poller and the Auto-Yes poller.
+ * They used to read it three ways — the Auto-Yes poller through the agy receipt
+ * window, which turns a real confirmation outside the window into "no prompt" —
+ * and a wait one of them saw as a person's screen another saw as nothing. Here
+ * is the one reading they share: whether the frame waits, what kind of wait it
+ * is, and whether only a person can end it (`humanHeld`), from the detector's
+ * verdict WITHOUT the receipt scope.
+ *
+ * `humanHeld` (規則 1) is all of: the detector says `waiting`, the same
+ * verdict's prompt reading says there is no prompt, and the agent reported no
+ * structured wait. So a copilot `ask_user` with four or more options (a prompt
+ * the detector reads, `isPrompt: true`) and an opencode permission strip the
+ * agent reported a decision for (a structured wait) are not a person's screen;
+ * a survey, a picker or a trust screen is.
+ *
+ * Detection layer: reads the detector and the waiting taxonomy, and nothing in
+ * `polling/` or the session stores.
+ *
+ * @module lib/detection/waiting-screen-reading
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitingReadingFromVerdict = waitingReadingFromVerdict;
+exports.promptWaitingReading = promptWaitingReading;
+exports.readWaitingScreen = readWaitingScreen;
+const status_detector_1 = require("./status-detector");
+const status_reason_1 = require("./status-reason");
+const waiting_kind_1 = require("../../lib/session/waiting-kind");
+/**
+ * The reasons that mean "no rule could read this frame" — the set
+ * `session/status-evidence`'s `isUnclassifiedFrame` names. Restated rather than
+ * imported because that module sits above this layer (it reads the agent's
+ * event store).
+ */
+const UNCLASSIFIED_REASONS = new Set([
+    status_reason_1.STATUS_REASON.NO_RECENT_OUTPUT,
+    status_reason_1.STATUS_REASON.UNKNOWN_FRAME,
+    status_reason_1.STATUS_REASON.DEFAULT,
+]);
+/**
+ * A reading from a verdict the caller has already made, with the caller's own
+ * composed answer to "is it waiting" (the status probe folds the structured
+ * layer and a launch in progress into it). `humanHeld` is decided here and
+ * nowhere else.
+ */
+function waitingReadingFromVerdict(input) {
+    if (!input.waiting)
+        return { kind: 'not-waiting' };
+    const { verdict } = input;
+    return {
+        kind: 'waiting',
+        waitingKind: input.waitingKind,
+        humanHeld: verdict.status === 'waiting' && verdict.promptDetection.isPrompt === false && !input.structuredWaiting,
+        promptData: verdict.promptDetection.promptData ?? null,
+        structuredSince: input.structuredSince,
+    };
+}
+/**
+ * The reading of a prompt an observer has already read off the frame (the
+ * response poller's saved prompt). A prompt is never a person's screen.
+ */
+function promptWaitingReading(promptData) {
+    return { kind: 'waiting', waitingKind: 'prompt', humanHeld: false, promptData, structuredSince: null };
+}
+/**
+ * Read one captured frame (design §2.2). The detector is asked without the
+ * receipt scope (I9); the structured wait, and whether the app answers it over
+ * the agent's API, are the caller's to look up — the status probe's reading of
+ * the same frame gives the same kind only when both are passed.
+ *
+ * `verdict` is the detector's answer on this same frame when the caller has
+ * already asked for it (to look the structured wait up with), so the frame is
+ * not judged twice.
+ */
+function readWaitingScreen(input) {
+    const verdict = input.verdict ?? (0, status_detector_1.detectSessionStatus)(input.output, input.cliToolId, input.lastOutputTimestamp);
+    if (verdict.status === 'running' && UNCLASSIFIED_REASONS.has(verdict.reason))
+        return { kind: 'unknown' };
+    const waiting = verdict.status === 'waiting' || verdict.hasActivePrompt || input.structuredWaiting;
+    return waitingReadingFromVerdict({
+        verdict,
+        waiting,
+        waitingKind: (0, waiting_kind_1.deriveWaitingKind)({
+            waiting,
+            hasActivePrompt: verdict.hasActivePrompt,
+            scraperStatus: verdict.status,
+            scraperReason: verdict.reason,
+            apiAnswerable: input.apiAnswerable === true,
+        }),
+        structuredWaiting: input.structuredWaiting,
+        structuredSince: input.structuredSince,
+    });
+}

package/dist/server/src/lib/hooks/permission-decision-service.js

@@ -119,6 +119,13 @@ function readContractPolicy(session) {
  * | policy suppresses (mode off, deny pattern, type) | no-decision + suppression |
  * | otherwise | allow |
  *
+ * Issue #3822: the screen path reads the grant and the contract once more right
+ * before its first key (`withheldAtSend`). This path has no such moment: the
+ * `allow` returned here IS the answer — Claude runs the call without drawing a
+ * dialog and nothing is typed afterwards — so the grant and the contract it is
+ * judged against are read now, when the hook is answered, and the contract
+ * through the same cache-backed lookup (a failed read withholds, #3830).
+ *
  * @param session - Worktree / tool / instance the request came from
  * @param payload - Parsed payload, or null when it could not be parsed
  * @param deps - Substitutions for the database-backed lookups; see

package/dist/server/src/lib/hooks/structured-decision-response.js

@@ -465,5 +465,5 @@ async function answerStructuredDecision({ worktreeId, cliToolId, instanceId, ans
         reply: option.reply,
         delivered,
     });
-    return { kind: 'answered', decisionId: decision.id, option, delivered };
+    return { kind: 'answered', decisionId: decision.id, option, delivered, receipt: delivery };
 }

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

@@ -7,8 +7,8 @@
  * 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.
+ * fallback (`useAutoYes`, which answered only while no server poller ran, and
+ * since Issue #3821 answers nothing) 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

package/dist/server/src/lib/polling/auto-yes-confirmation-ledger-types.js

@@ -72,6 +72,9 @@ const WITHHOLD_REASONS = {
     'partial-answer': true,
     'startup-trust-unhandled': true,
     'question-confirm-page': true,
+    'question-left-to-human': true,
+    'allow-once-unidentified': true,
+    'recommended-option-unidentified': true,
     'no-hook-receipt': true,
     'send-failed': true,
     'send-no-keys': true,

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

@@ -243,6 +243,8 @@ function runHour(state, at) {
             presence: entry.presence,
             answerability: interval === null ? 'answerable' : 'withheld',
             withheldMsTotal: entry.withheldMsClosed + intervalMs,
+            // Issue #3863: the mode of the open interval, else of the last decision.
+            ...answerModeField(interval?.answerMode ?? entry.answerMode),
             ...(interval !== null
                 ? { intervalId: interval.id, reason: interval.reason, intervalStartedAtMs: interval.startedAt, intervalMs }
                 : {}),
@@ -252,11 +254,20 @@ function runHour(state, at) {
 // =============================================================================
 // Intervals and closing
 // =============================================================================
-function withhold(state, entry, reason, now) {
+/** Issue #3863: `{ answerMode }` when there is one, else nothing (the line keeps its old shape). */
+function answerModeField(answerMode) {
+    return answerMode === undefined ? {} : { answerMode };
+}
+function withhold(state, entry, reason, now, answerMode = entry.answerMode) {
     const interval = entry.interval;
     if (interval === null) {
         entry.intervals += 1;
-        const opened = { id: `${entry.id}#${entry.intervals}`, startedAt: now, reason };
+        const opened = {
+            id: `${entry.id}#${entry.intervals}`,
+            startedAt: now,
+            reason,
+            ...answerModeField(answerMode),
+        };
         entry.interval = opened;
         (0, auto_yes_ledger_records_1.emit)(state, auto_yes_confirmation_ledger_types_1.AUTO_YES_LEDGER_EVENTS.withholdStarted, {
             atMs: now,
@@ -266,6 +277,7 @@ function withhold(state, entry, reason, now) {
             source: entry.source,
             reason,
             startedAtMs: now,
+            ...answerModeField(answerMode),
         });
         return;
     }
@@ -300,6 +312,7 @@ function endInterval(state, entry, end, now) {
         withheldMs,
         end,
         lastReason: interval.reason,
+        ...answerModeField(interval.answerMode),
     });
 }
 function closeEntry(state, entry, now, how) {
@@ -356,6 +369,10 @@ function closeEntry(state, entry, now, how) {
         // The screen path cannot tell Auto-Yes's keys from a human's; only a
         // delivered reply that released it is known to be Auto-Yes's (design §2.6).
         resolvedBy: how.kind === 'reply' ? 'auto' : how.kind === 'gone' ? (how.resolvedBy ?? 'unknown') : 'unknown',
+        // Issue #3863: the mode the last decision about it was made under, and
+        // the mode of the send that answered it (which a later decision does not move).
+        ...answerModeField(entry.answerMode),
+        ...(entry.answeredAnswerMode !== undefined ? { answeredAnswerMode: entry.answeredAnswerMode } : {}),
         openMs: Math.max(0, now - entry.openedAt),
         withheldMsTotal: entry.withheldMsClosed,
         unobservableMs: entry.unobservableMs,
@@ -552,6 +569,8 @@ function withholdLedgerConfirmation(scope, reason) {
         if (entry === undefined || entry.presence !== 'present')
             return;
         entry.decision = 'withhold';
+        if (scope.answerMode !== undefined)
+            entry.answerMode = scope.answerMode;
         withhold(state, entry, reason, now);
     });
 }
@@ -566,6 +585,8 @@ function beginLedgerAttempt(scope, basis, options = {}) {
         const entry = (0, auto_yes_ledger_records_1.currentEntry)(state, (0, auto_yes_ledger_records_1.keyOf)(scope));
         if (entry === undefined)
             return null;
+        if (scope.answerMode !== undefined)
+            entry.answerMode = scope.answerMode;
         return beginAttempt(state, entry, basis, options.receiptAccepted === true);
     });
 }
@@ -579,7 +600,13 @@ function beginAttempt(state, entry, basis, receiptAccepted) {
         if (oldest !== undefined)
             state.pending.delete(oldest);
     }
-    state.pending.set(handle.attemptId, { confirmationId: entry.id, cliToolId: entry.cliToolId, basis, receiptAccepted });
+    state.pending.set(handle.attemptId, {
+        confirmationId: entry.id,
+        cliToolId: entry.cliToolId,
+        basis,
+        receiptAccepted,
+        ...answerModeField(entry.answerMode),
+    });
     return handle;
 }
 const WITHHOLD_REASON_OF_RESULT = {
@@ -616,11 +643,15 @@ function settleAttempt(state, handle, result, expired, now, options = {}) {
         late: entry === undefined,
         expired,
         ...(pending.receiptAccepted ? { receiptAccepted: true } : {}),
+        ...answerModeField(pending.answerMode),
     });
     if (entry === undefined)
         return;
     if (result === 'ok') {
         entry.attempts.ok += 1;
+        // Issue #3863: the first send that answered it says which mode answered it.
+        if (!entry.answered && pending.answerMode !== undefined)
+            entry.answeredAnswerMode = pending.answerMode;
         entry.answered = true;
         endInterval(state, entry, 'answered', now);
         return;

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

@@ -0,0 +1,195 @@
+"use strict";
+/**
+ * Auto-Yes's decision about the confirmation on screen (Issue #3821).
+ *
+ * Written by the poller's tick (`detectAndRespondToPrompt`), which is where the
+ * decision is actually made, and read by `buildCurrentOutput`, which publishes
+ * it as `autoYesDecision` next to the prompt. The answer surfaces show their
+ * panel under Auto-Yes for every decision but `answering`.
+ *
+ * ## What a record is tied to
+ *
+ * A record is published only while everything it was made under still holds:
+ *
+ * - the GRANT — the same `AutoYesState` object (`getAutoYesState` stores a new
+ *   one on every enable and on expiry, as the tick's own generation check
+ *   reads it, #3706), so turning Auto-Yes off and on again or letting it expire
+ *   drops the old decision even with the same screen up;
+ * - the SESSION epoch (`getEnterFallbackSessionEpoch`): a relaunch drops it;
+ * - the CONFIRMATION ({@link matchesConfirmation}): the question and the
+ *   options ({@link enterFallbackScreenKey}), AND what is being approved — the
+ *   whole `approvalTarget` as read, with only the cursor on its option rows
+ *   taken out ({@link approvalTargetRows}, the body's indent, `>` and blank
+ *   rows kept, as #3817 reads it) — AND, for agy, the hook call the receipt
+ *   was accepted for. Two approvals that differ only in their target (agy's
+ *   file creation names the file only there, two commands that differ by an
+ *   indent) are two confirmations. Two readings of one screen that differ in
+ *   how many rows they kept (one cut from the top) are not matched either:
+ *   the rows a cut leaves need not name what is approved (a diff row, not the
+ *   file), and the hook call known now may be an earlier one's (review 3), so
+ *   they read `none` — the panel opens, nothing is sent. The published
+ *   `confirmation` ({@link autoYesConfirmationKey}) is this same identity: a
+ *   record matches exactly when the keys are equal;
+ * - a TICK not long ago ({@link AUTO_YES_DECISION_STALE_MS}): a live poller
+ *   re-decides every tick, so a record nobody refreshed says nothing now.
+ *
+ * Anything else — no record, another confirmation, an old grant — is `none`,
+ * never `answering`. A human's answer through `/prompt-response` drops the
+ * record (`./auto-yes-manual-answer`).
+ *
+ * Two confirmations identical in every part above, in a row, with no frame
+ * without a prompt between them, read as one here: nothing on the screen tells
+ * them apart. The tick re-decides on its next pass either way.
+ *
+ * Not the confirmation ledger (#3820): the ledger measures, never decides, and
+ * a failure in it changes nothing. This record is what the tick decided.
+ *
+ * In-memory and on `globalThis` for the reason `auto-yes-suppression-state`
+ * gives: the poller writes it and the `current-output` route reads it, and
+ * under `next dev` the two are bundled apart.
+ *
+ * @module lib/polling/auto-yes-decision-state
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AUTO_YES_DECISION_STALE_MS = void 0;
+exports.approvalTargetRows = approvalTargetRows;
+exports.autoYesConfirmationKey = autoYesConfirmationKey;
+exports.matchesConfirmation = matchesConfirmation;
+exports.recordAutoYesDecision = recordAutoYesDecision;
+exports.reaffirmAutoYesAnswering = reaffirmAutoYesAnswering;
+exports.getAutoYesDecisionRecord = getAutoYesDecisionRecord;
+exports.forgetAutoYesDecision = forgetAutoYesDecision;
+exports.forgetAutoYesDecisionsByWorktree = forgetAutoYesDecisionsByWorktree;
+exports.clearAutoYesDecisions = clearAutoYesDecisions;
+exports.publishAutoYesDecision = publishAutoYesDecision;
+const auto_yes_state_1 = require("../../lib/auto-yes-state");
+const auto_yes_decision_1 = require("../../types/auto-yes-decision");
+const global_state_1 = require("../global-state");
+const auto_yes_enter_fallback_state_1 = require("./auto-yes-enter-fallback-state");
+const auto_yes_poller_state_1 = require("./auto-yes-poller-state");
+const crypto_1 = require("crypto");
+/**
+ * How long a record stays current without a tick refreshing it. The poller
+ * ticks every couple of seconds and refreshes the record on each tick that
+ * sees the screen; one past this is from a poller that is not ticking.
+ */
+exports.AUTO_YES_DECISION_STALE_MS = 30_000;
+const decisions = (0, global_state_1.getOrInitGlobal)('__autoYesDecisions', () => new Map());
+/**
+ * The rows of `approvalTarget` with only the cursor taken out of its option
+ * rows (`approvalTargetWithoutCursor`), or null when the prompt has none. The
+ * body stays as read: an indent, a `>` or a blank row is part of what is
+ * approved (#3817).
+ */
+function approvalTargetRows(promptData) {
+    const target = (0, auto_yes_poller_state_1.approvalTargetWithoutCursor)(promptData);
+    return target === null ? null : target.split('\n');
+}
+/**
+ * Which confirmation a reading is of: question and options
+ * ({@link enterFallbackScreenKey}), the approval target row for row
+ * ({@link approvalTargetRows}) and the agy call, hashed. The one identity both
+ * the record ({@link matchesConfirmation}) and the wire (`confirmation`, read
+ * by `laterAutoYesDecision`) use: same key, same confirmation; another key,
+ * another confirmation — or the same one read with other rows, which is not
+ * claimed to be the same.
+ */
+function autoYesConfirmationKey(identity) {
+    return (0, crypto_1.createHash)('sha256')
+        .update(JSON.stringify([
+        (0, auto_yes_enter_fallback_state_1.enterFallbackScreenKey)(identity.promptData),
+        approvalTargetRows(identity.promptData),
+        identity.callId ?? null,
+    ]))
+        .digest('hex')
+        .slice(0, 32);
+}
+/** Is `record` about the confirmation `identity` describes? The same {@link autoYesConfirmationKey}. */
+function matchesConfirmation(record, identity) {
+    return record.confirmation === autoYesConfirmationKey(identity);
+}
+/** Record what the tick decided for the prompt on screen. */
+function recordAutoYesDecision(compositeKey, decision, at = Date.now()) {
+    decisions.set(compositeKey, {
+        state: decision.state,
+        reason: decision.state === 'withheld' ? decision.reason : null,
+        confirmation: autoYesConfirmationKey(decision),
+        grant: decision.grant,
+        epoch: decision.epoch,
+        at,
+    });
+}
+/**
+ * Issue #3821 (review 2): the duplicate guard (#306) says "answered less than
+ * `DUPLICATE_RETRY_EXPIRY_MS` ago", comparing only the type and the question.
+ * That is not evidence the confirmation on screen is the one answered, so the
+ * `answering` record is only kept — its time moved on — when it is the one
+ * this tick's send made: about this very confirmation, under the same grant
+ * and session. Otherwise the record is dropped (`none`).
+ *
+ * @returns Whether `answering` still stands
+ */
+function reaffirmAutoYesAnswering(compositeKey, tick, at = Date.now()) {
+    const record = decisions.get(compositeKey);
+    if (record === undefined ||
+        record.state !== 'answering' ||
+        record.grant !== tick.grant ||
+        record.epoch !== tick.epoch ||
+        !matchesConfirmation(record, tick)) {
+        decisions.delete(compositeKey);
+        return false;
+    }
+    decisions.set(compositeKey, { ...record, at });
+    return true;
+}
+/** The record as kept, or null. Test seam and diagnostics. */
+function getAutoYesDecisionRecord(compositeKey) {
+    return decisions.get(compositeKey) ?? null;
+}
+/** Drop one instance's record: no prompt on screen, a human answered, the poller stopped. */
+function forgetAutoYesDecision(compositeKey) {
+    decisions.delete(compositeKey);
+}
+/** {@link forgetAutoYesDecision} for every instance of a worktree. */
+function forgetAutoYesDecisionsByWorktree(worktreeId) {
+    for (const key of (0, auto_yes_state_1.filterCompositeKeysByWorktree)([...decisions.keys()], worktreeId)) {
+        decisions.delete(key);
+    }
+}
+/** Drop every record: server shutdown, and a test seam. */
+function clearAutoYesDecisions() {
+    decisions.clear();
+}
+/**
+ * The decision published for the payload's prompt.
+ *
+ * - no screen prompt, or Auto-Yes off: `none`;
+ * - Auto-Yes on with no poller for the instance: `withheld`
+ *   (`server-poller-inactive`) — nothing answers the screen, whatever an
+ *   earlier record said;
+ * - a record made under this grant and session, about this confirmation
+ *   ({@link matchesConfirmation}), refreshed recently: that record;
+ * - otherwise `none`.
+ *
+ * Each names the payload's prompt in `confirmation` ({@link autoYesConfirmationKey}; null with no prompt).
+ */
+function publishAutoYesDecision(input) {
+    const now = input.now ?? Date.now();
+    const { compositeKey, grant, promptData } = input;
+    const confirmation = promptData == null ? null : autoYesConfirmationKey({ promptData, callId: input.callId });
+    const none = { state: 'none', reason: null, observedAt: now, confirmation };
+    if (promptData == null || !grant?.enabled)
+        return none;
+    if (!input.pollerActive) {
+        return { state: 'withheld', reason: auto_yes_decision_1.SERVER_POLLER_INACTIVE_DECISION_REASON, observedAt: now, confirmation };
+    }
+    const record = decisions.get(compositeKey);
+    if (record === undefined ||
+        record.grant !== grant ||
+        record.epoch !== (0, auto_yes_enter_fallback_state_1.getEnterFallbackSessionEpoch)(compositeKey) ||
+        record.confirmation !== confirmation ||
+        now - record.at > exports.AUTO_YES_DECISION_STALE_MS) {
+        return none;
+    }
+    return { state: record.state, reason: record.reason, observedAt: now, confirmation };
+}