commandmate 0.44.1 → 0.44.3

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

@@ -0,0 +1,187 @@
+"use strict";
+/**
+ * Auto-Yes's Enter on a choice screen CommandMate cannot read (Issue #3397).
+ *
+ * ## The screen
+ *
+ * `assessPromptAnswerability` refuses some frames that are plainly a choice
+ * screen: an AskUserQuestion picker whose layout no rule could verify
+ * (`unsupported_dialog_layout`), or a numbered list the tool's `detectDialog`
+ * does not recognise (`prompt_no_longer_active`). The prompt window then says
+ * "this screen cannot be operated from CommandMate" and offers direct input,
+ * and Auto-Yes — whose dialog gate (#1928) reads the same frame — sends nothing.
+ *
+ * With Auto-Yes on, that leaves an unattended worker waiting for a human on a
+ * screen where one Enter (confirm whatever is selected now) would do.
+ *
+ * ## When Enter is sent
+ *
+ * {@link judgeEnterFallback} answers for the frame, and the poller adds the
+ * rest (the policy, the session's owner, sending once per screen):
+ *
+ *  1. the tool is enabled in {@link AUTO_YES_ENTER_FALLBACK_DEFAULT_MODE} (or by
+ *     {@link AUTO_YES_ENTER_FALLBACK_ENV_VAR});
+ *  2. `assessPromptAnswerability(cliToolId, raw).refusal !== null` — the SAME
+ *     reading the status API publishes as `promptAnswerable`, so the screen
+ *     that shows the direct-input link and the screen that gets an Enter are
+ *     one set of frames, not two copies of a rule;
+ *  3. there is evidence that the pane's focus is on a choice screen:
+ *     `unsupported_dialog_layout` (the picker's own footer is on screen), or a
+ *     claude / codex frame whose input box is not on screen (`no_composer`);
+ *  4. the input box is NOT on screen (`content` / `ghost` / `empty`). Not even
+ *     for `unsupported_dialog_layout`: with the composer up, the list is far more
+ *     likely an agent's reply quoting one (#1896), and an Enter would submit
+ *     whatever sits in the composer — the shape of the accident in which a
+ *     parked `/create-pr` was confirmed without anyone asking for it;
+ *  5. the tool is still on the pane (a shell prompt under the list means the
+ *     agent exited) and is not thinking (a frame mid-stream is not a screen).
+ *
+ * Everything not decided here is decided on the safe side — no Enter.
+ *
+ * ## Out of scope
+ *
+ * opencode / copilot's arrow-key screens (`answerMode: 'keys'`, #1893 — an
+ * Enter there confirms whatever is highlighted, which once turned a Reject into
+ * an Approve), multi-select screens and options that need typed text (the
+ * poller asks `resolveAutoAnswerWithPolicy`, which answers null for both), and
+ * Antigravity (its frames reach Auto-Yes only with a hook receipt, #2849).
+ *
+ * @module lib/polling/auto-yes-enter-fallback
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEnterFallbackSessionEpoch = exports.beginEnterFallbackSession = exports.clearEnterFallbacks = exports.forgetEnterFallbacksByWorktree = exports.forgetEnterFallback = exports.publishEnterFallback = exports.getLastEnterFallback = exports.recordEnterFallbackNoEffect = exports.recordEnterFallbackSent = exports.enterFallbackScreenKey = exports.AUTO_YES_ENTER_FALLBACK_ENV_VAR = exports.AUTO_YES_ENTER_FALLBACK_DEFAULT_MODE = exports.AUTO_YES_ENTER_FALLBACK_MODES = void 0;
+exports.resolveAutoYesEnterFallbackMode = resolveAutoYesEnterFallbackMode;
+exports.judgeEnterFallback = judgeEnterFallback;
+const liveness_spec_1 = require("../../lib/cli-tools/liveness-spec");
+const tool_liveness_1 = require("../../lib/detection/tool-liveness");
+const composer_text_1 = require("../../lib/detection/composer-text");
+const cli_patterns_1 = require("../../lib/detection/cli-patterns");
+const auto_yes_state_1 = require("../../lib/auto-yes-state");
+const auto_yes_dialog_gate_1 = require("./auto-yes-dialog-gate");
+/** Every accepted value of {@link AutoYesEnterFallbackMode}, for parsing and tests. */
+exports.AUTO_YES_ENTER_FALLBACK_MODES = ['enabled', 'disabled'];
+/**
+ * The state each tool ships in.
+ *
+ * `enabled` only for claude and codex: they are the two tools whose input box
+ * can be located (`SUPPORTED_COMPOSER_TOOLS` in `detection/composer-text`), so
+ * they are the only two for which "the composer is not on screen" can be read
+ * at all — and condition 4 of the module docstring is what keeps #1896 from
+ * coming back. Every other tool stays as it was: the frame is left to a human.
+ */
+exports.AUTO_YES_ENTER_FALLBACK_DEFAULT_MODE = {
+    claude: 'enabled',
+    codex: 'enabled',
+    copilot: 'disabled',
+    opencode: 'disabled',
+    'opencode-v2': 'disabled',
+    gemini: 'disabled',
+    antigravity: 'disabled',
+    'vibe-local': 'disabled',
+    'command-code': 'disabled',
+};
+/**
+ * The switch, spelled like `CM_AUTOYES_DIALOG_GATE`: comma-separated
+ * `<tool>=<mode>` pairs, `*` for every tool, a tool-specific entry beating `*`.
+ *
+ * ```
+ * CM_AUTOYES_ENTER_FALLBACK=*=disabled        # never send the Enter
+ * CM_AUTOYES_ENTER_FALLBACK=codex=disabled    # claude only
+ * ```
+ *
+ * Read on every poll, so an operator can turn it off without a restart.
+ */
+exports.AUTO_YES_ENTER_FALLBACK_ENV_VAR = 'CM_AUTOYES_ENTER_FALLBACK';
+function isMode(value) {
+    return exports.AUTO_YES_ENTER_FALLBACK_MODES.includes(value);
+}
+/**
+ * Resolve one tool's mode. An unparseable entry is ignored rather than thrown:
+ * this runs on the polling path.
+ *
+ * @param tool - CLI tool to resolve for
+ * @param env - Environment to read; injectable for tests
+ */
+function resolveAutoYesEnterFallbackMode(tool, env = process.env) {
+    const raw = env[exports.AUTO_YES_ENTER_FALLBACK_ENV_VAR];
+    let wildcard = null;
+    let specific = null;
+    if (typeof raw === 'string' && raw.trim() !== '') {
+        for (const entry of raw.split(',')) {
+            const [rawKey, rawValue] = entry.split('=');
+            if (rawValue === undefined)
+                continue;
+            const key = rawKey.trim();
+            const value = rawValue.trim();
+            if (!isMode(value))
+                continue;
+            if (key === '*')
+                wildcard = value;
+            else if (key === tool)
+                specific = value;
+        }
+    }
+    return specific ?? wildcard ?? exports.AUTO_YES_ENTER_FALLBACK_DEFAULT_MODE[tool] ?? 'disabled';
+}
+/** The composer states that mean "the input box is on screen". */
+const COMPOSER_ON_SCREEN = new Set(['content', 'ghost', 'empty']);
+/** The tools whose `no_composer` is a measured reading (see `SUPPORTED_COMPOSER_TOOLS`). */
+const NO_COMPOSER_EVIDENCE_TOOLS = new Set(['claude', 'codex']);
+/**
+ * May Auto-Yes send its Enter at this frame? Conditions 1-5 of the module
+ * docstring, in that order; the policy, the session's owner and "once per
+ * screen" are the poller's.
+ *
+ * @param cliToolId - CLI tool the frame came from
+ * @param rawOutput - The tick's capture as captured (ANSI and box drawing
+ *   intact). `undefined` is refused: the composer's dim placeholder is only
+ *   distinguishable with the SGR attributes, and box drawing is what locates it.
+ * @param env - Environment to read the switch from; injectable for tests
+ */
+function judgeEnterFallback(cliToolId, rawOutput, env = process.env) {
+    if (resolveAutoYesEnterFallbackMode(cliToolId, env) !== 'enabled') {
+        return { eligible: false, reason: 'tool-disabled', refusalReason: null, composerState: null };
+    }
+    if (rawOutput === undefined) {
+        return { eligible: false, reason: 'no-raw-frame', refusalReason: null, composerState: null };
+    }
+    const refusal = (0, auto_yes_dialog_gate_1.assessPromptAnswerability)(cliToolId, rawOutput).refusal;
+    if (refusal === null) {
+        return { eligible: false, reason: 'answerable', refusalReason: null, composerState: null };
+    }
+    const composerState = (0, composer_text_1.extractComposerText)(rawOutput, cliToolId).state;
+    const ineligible = (reason) => ({
+        eligible: false,
+        reason,
+        refusalReason: refusal.reason,
+        composerState,
+    });
+    if (COMPOSER_ON_SCREEN.has(composerState))
+        return ineligible('composer-visible');
+    const pickerFooterOnScreen = refusal.reason === auto_yes_dialog_gate_1.UNSUPPORTED_DIALOG_LAYOUT_REASON;
+    const composerOffScreen = NO_COMPOSER_EVIDENCE_TOOLS.has(cliToolId) && composerState === 'no_composer';
+    if (!pickerFooterOnScreen && !composerOffScreen)
+        return ineligible('no-choice-screen-evidence');
+    if (!(0, tool_liveness_1.judgeToolLiveness)(rawOutput, (0, liveness_spec_1.resolveLivenessSpec)(cliToolId)).alive) {
+        return ineligible('tool-exited');
+    }
+    const recentLines = (0, cli_patterns_1.stripAnsi)(rawOutput).split('\n').slice(-auto_yes_state_1.THINKING_CHECK_LINE_COUNT).join('\n');
+    if ((0, cli_patterns_1.detectThinking)(cliToolId, recentLines))
+        return ineligible('thinking');
+    return { eligible: true, refusalReason: refusal.reason, composerState };
+}
+// The screen key, the record and the session epoch live in
+// `./auto-yes-enter-fallback-state` (Issue #3397, review round 2): a module with
+// no detection imports, so `agent-session-lifecycle` — on every tool's
+// `startSession` path — can expire the record without pulling this one in.
+var auto_yes_enter_fallback_state_1 = require("./auto-yes-enter-fallback-state");
+Object.defineProperty(exports, "enterFallbackScreenKey", { enumerable: true, get: function () { return auto_yes_enter_fallback_state_1.enterFallbackScreenKey; } });
+Object.defineProperty(exports, "recordEnterFallbackSent", { enumerable: true, get: function () { return auto_yes_enter_fallback_state_1.recordEnterFallbackSent; } });
+Object.defineProperty(exports, "recordEnterFallbackNoEffect", { enumerable: true, get: function () { return auto_yes_enter_fallback_state_1.recordEnterFallbackNoEffect; } });
+Object.defineProperty(exports, "getLastEnterFallback", { enumerable: true, get: function () { return auto_yes_enter_fallback_state_1.getLastEnterFallback; } });
+Object.defineProperty(exports, "publishEnterFallback", { enumerable: true, get: function () { return auto_yes_enter_fallback_state_1.publishEnterFallback; } });
+Object.defineProperty(exports, "forgetEnterFallback", { enumerable: true, get: function () { return auto_yes_enter_fallback_state_1.forgetEnterFallback; } });
+Object.defineProperty(exports, "forgetEnterFallbacksByWorktree", { enumerable: true, get: function () { return auto_yes_enter_fallback_state_1.forgetEnterFallbacksByWorktree; } });
+Object.defineProperty(exports, "clearEnterFallbacks", { enumerable: true, get: function () { return auto_yes_enter_fallback_state_1.clearEnterFallbacks; } });
+Object.defineProperty(exports, "beginEnterFallbackSession", { enumerable: true, get: function () { return auto_yes_enter_fallback_state_1.beginEnterFallbackSession; } });
+Object.defineProperty(exports, "getEnterFallbackSessionEpoch", { enumerable: true, get: function () { return auto_yes_enter_fallback_state_1.getEnterFallbackSessionEpoch; } });

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

@@ -4,8 +4,9 @@
  *
  * Base rules (unchanged since Issue #479):
  * - yes/no prompt -> 'y'
- * - multiple_choice with `multiSelect: true` -> null (Issue #2755: the number
- *   ticks a box, the confirm is a separate row, so a default is half an answer)
+ * - multiple_choice with `multiSelect: true`, or option labels that wear a
+ *   checkbox (Issue #3397) -> null (Issue #2755: the number ticks a box, the
+ *   confirm is a separate row, so a default is half an answer)
  * - multiple_choice with default option -> default option number
  * - multiple_choice without default -> first option number
  * - option requiring text input -> null (skip)
@@ -26,6 +27,7 @@ exports.evaluatePolicyAgainstTexts = evaluatePolicyAgainstTexts;
 exports.resolveAutoAnswerWithPolicy = resolveAutoAnswerWithPolicy;
 exports.resolveAutoAnswer = resolveAutoAnswer;
 const auto_yes_config_1 = require("../../config/auto-yes-config");
+const prompt_answer_semantic_1 = require("../../lib/prompt-answer-semantic");
 /**
  * Upper bound on a deny pattern, mirroring MAX_PATTERN_LENGTH in
  * lib/tasks/contract-parser (asserted equal by the unit tests). Contracts are
@@ -50,7 +52,11 @@ function resolveBaseAnswer(promptData) {
         // Issue #2755: a checkbox question. A number ticks a box and the confirm is
         // a separate row, so "the default option" is not an answer — it is half of
         // one. Auto-Yes refuses the prompt instead of ticking something and stopping.
-        if (promptData.multiSelect === true) {
+        // Issue #3397: through the one checkbox reading (`isMultiSelectPrompt`), so
+        // a list the parser did not flag but whose labels wear boxes (`[ ]` / `[x]`
+        // / `[X]` / `[✔]`) is refused too — the sender answers such a list with
+        // Space→Next→Enter, which would tick the default and submit the list.
+        if ((0, prompt_answer_semantic_1.isMultiSelectPrompt)(promptData)) {
             return null;
         }
         const defaultOpt = promptData.options.find(o => o.isDefault);

package/dist/server/src/lib/polling/auto-yes-suppression-reason.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -27,9 +27,9 @@ exports.recordPolicySuppression = recordPolicySuppression;
 exports.getLastPolicySuppression = getLastPolicySuppression;
 exports.clearPolicySuppressions = clearPolicySuppressions;
 const auto_yes_state_1 = require("../../lib/auto-yes-state");
+const global_state_1 = require("../global-state");
 /** compositeKey -> the most recent policy suppression for that session. */
-const lastPolicySuppressions = globalThis.__autoYesPolicySuppressions ??
-    (globalThis.__autoYesPolicySuppressions = new Map());
+const lastPolicySuppressions = (0, global_state_1.getOrInitGlobal)('__autoYesPolicySuppressions', () => new Map());
 /**
  * Record that the policy withheld an answer for `instanceId`'s current prompt.
  *

package/dist/server/src/lib/polling/pending-scraped-response.js

@@ -0,0 +1,190 @@
+"use strict";
+/** Held scraped responses for CLI tool polling (Issue #3213 split from response-checker.ts). */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PENDING_SCRAPE_HOLD_MS = void 0;
+exports.resetPendingScrapedResponses = resetPendingScrapedResponses;
+exports.hasPendingScrapedResponse = hasPendingScrapedResponse;
+exports.holdScrapedResponse = holdScrapedResponse;
+exports.discardPendingScrapedResponse = discardPendingScrapedResponse;
+exports.flushPendingScrapedResponse = flushPendingScrapedResponse;
+exports.settleExpiredPendingScrapedResponse = settleExpiredPendingScrapedResponse;
+const db_instance_1 = require("../../lib/db/db-instance");
+const db_1 = require("../../lib/db");
+const ws_server_1 = require("../../lib/ws-server");
+const conversation_logger_1 = require("../../lib/conversation-logger");
+const logger_1 = require("../../lib/logger");
+const response_dedup_1 = require("./response-dedup");
+const structured_history_gate_1 = require("./structured-history-gate");
+const stop_history_capture_1 = require("../../lib/hooks/stop-history-capture");
+const global_state_1 = require("../global-state");
+const logger = (0, logger_1.createLogger)('response-poller');
+// ============================================================================
+// The held scrape (Issue #2436)
+// ============================================================================
+/**
+ * How long a scraped reply is held while its transcript finishes closing.
+ *
+ * Derived from `STOP_TRANSCRIPT_DEFERRED_DELAYS_MS`, not spelled again: those
+ * are the instants the Stop receiver re-reads the transcript at after it has
+ * answered the agent (#2398), so their SUM is the moment after which nobody is
+ * still trying. Holding past it would be holding for a row that has no producer
+ * left; stopping short of it would race the producer that is still running.
+ *
+ * The measured gap this covers is under a second — codex 2026-09-08 appended
+ * `task_complete` ~700 ms after the frame went quiet — so the budget is roughly
+ * ten times the case it exists for, spent only on turns that ask for it.
+ */
+exports.PENDING_SCRAPE_HOLD_MS = stop_history_capture_1.STOP_TRANSCRIPT_DEFERRED_DELAYS_MS.reduce((total, delay) => total + delay, 0);
+/**
+ * Held scrapes, by poller key.
+ *
+ * **Deliberately not in `./response-dedup`.** That module's two caches are
+ * cleared by `stopPollingByKey` — `clearResponseHashCache` is called from
+ * inside it — so a held reply parked beside them would be dropped by the very
+ * event that has to write it (Issue #2436, requirement B). It lives here, next
+ * to the code that fills it and the code that writes it out, and
+ * `flushPendingScrapedResponse` is what the poller calls before it clears
+ * anything.
+ *
+ * On `globalThis` for the reason every shared map in this subsystem is (#1736):
+ * under `next dev` the poller's bundle and each route's bundle would otherwise
+ * hold a private copy, and a held reply only one bundle can see is a lost one.
+ */
+const pendingScrapedResponses = (0, global_state_1.getOrInitGlobal)('__pendingScrapedResponses', () => new Map());
+/** Forget every held scrape. Test seam. */
+function resetPendingScrapedResponses() {
+    pendingScrapedResponses.clear();
+}
+/** Whether a scrape is being held for this poller key. Test seam / diagnostics. */
+function hasPendingScrapedResponse(pollerKey) {
+    return pendingScrapedResponses.has(pollerKey);
+}
+/**
+ * Hold this tick's scraped reply instead of writing it (Issue #2436).
+ *
+ * Called when the transcript reader has said `not_yet_closed`: the agent's own
+ * Markdown for this turn is coming, and writing the pane's copy now is what put
+ * 234,323 characters of prompt echo, intermediate output and footer into
+ * History beside the real answer.
+ *
+ * A second hold for the same key REPLACES the content and keeps the original
+ * deadline. Replaces, because a frame that moved on is a better copy of the
+ * same turn; keeps, because a pane that redraws every tick would otherwise push
+ * its own deadline forward forever and the hold would stop being bounded.
+ */
+function holdScrapedResponse(pollerKey, pending) {
+    const existing = pendingScrapedResponses.get(pollerKey);
+    if (existing) {
+        existing.content = pending.content;
+        return;
+    }
+    pendingScrapedResponses.set(pollerKey, pending);
+}
+/**
+ * Drop a held scrape without writing it (Issue #2436).
+ *
+ * The one thing that justifies dropping it: the transcript reader has since
+ * written the turn as the agent's own Markdown, so the pane's copy is the
+ * duplicate this Issue exists to stop.
+ */
+function discardPendingScrapedResponse(pollerKey) {
+    pendingScrapedResponses.delete(pollerKey);
+}
+/**
+ * Write a held scrape now, whatever the clock says (Issue #2436).
+ *
+ * Exported because `response-poller-core` calls it from `stopPollingByKey`,
+ * which is every way a polling cycle ends: an explicit stop, the session going
+ * away, `MAX_POLLING_DURATION`, and the restart that opens the NEXT turn. A
+ * held reply must not be able to outlive the cycle that holds it — the caches
+ * that key it are cleared in that same function, and a reply nobody writes is
+ * strictly worse than the duplicate row this Issue is trading against.
+ *
+ * **Deliberately bypasses `isDuplicateResponse`.** The hash for this content was
+ * registered by the tick that decided to hold it (the dedup guard's check is
+ * also its write), so a re-check here would answer "duplicate" for the reply
+ * that has never been saved. That is requirement A of the Issue in one line.
+ *
+ * Synchronous through the row: `better-sqlite3` is, and this runs on shutdown
+ * paths where an awaited continuation may never be reached. The Markdown
+ * conversation log is fired afterwards and not waited for, because it is a
+ * secondary record and the row is the one History reads.
+ *
+ * @param pollerKey - Poller key ("worktreeId:instanceId")
+ * @param reason - What ended the hold; logged, for the operator reading back
+ * @returns Whether a held reply was written
+ */
+function flushPendingScrapedResponse(pollerKey, reason) {
+    const pending = pendingScrapedResponses.get(pollerKey);
+    if (!pending)
+        return false;
+    pendingScrapedResponses.delete(pollerKey);
+    try {
+        const db = (0, db_instance_1.getDbInstance)();
+        const message = (0, db_1.createMessage)(db, {
+            worktreeId: pending.worktreeId,
+            role: 'assistant',
+            content: pending.content,
+            messageType: 'normal',
+            timestamp: pending.timestamp,
+            cliToolId: pending.cliToolId,
+            instanceId: pending.instanceId,
+            summary: pending.summary,
+            logFileName: pending.logFileName,
+            requestId: pending.requestId,
+        });
+        (0, ws_server_1.broadcastMessage)('message', { worktreeId: pending.worktreeId, message });
+        logger.info('pending-scrape-flushed', {
+            worktreeId: pending.worktreeId,
+            cliToolId: pending.cliToolId,
+            instanceId: pending.instanceId,
+            reason,
+            scrapedLength: pending.content.length,
+            heldForMs: Date.now() - pending.timestamp.getTime(),
+        });
+        void (0, conversation_logger_1.recordClaudeConversation)(db, pending.worktreeId, pending.content, pending.cliToolId).catch(() => { });
+        return true;
+    }
+    catch (error) {
+        logger.warn('pending-scrape-flush-failed', {
+            worktreeId: pending.worktreeId,
+            cliToolId: pending.cliToolId,
+            instanceId: pending.instanceId,
+            reason,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return false;
+    }
+}
+/**
+ * End a hold whose deadline has passed, one way or the other (Issue #2436).
+ *
+ * Run at the top of every tick, because the tick that has to notice an expiry
+ * is very often one that returns early — a static frame yields no new lines for
+ * a scrollback tool and is a duplicate for an alternate-screen one, and neither
+ * of those paths reaches the save block at the bottom of `checkForResponse`.
+ *
+ * The reader is asked ONE more time before the row is written. By the deadline
+ * the throttled recheck (#2399) has usually already captured the turn and
+ * dropped the hold, but the two are not in step — the recheck is every third
+ * duplicate tick and this is a wall clock — and a last read costs one tail
+ * parse against writing a pane dump that is about to be superseded.
+ */
+async function settleExpiredPendingScrapedResponse(pollerKey) {
+    const pending = pendingScrapedResponses.get(pollerKey);
+    if (!pending || Date.now() < pending.expiresAt)
+        return;
+    const captured = await (0, structured_history_gate_1.captureStructuredHistoryTurn)(pending.worktreeId, pending.cliToolId, pending.instanceId, { worktreePath: pending.worktreePath, transcriptPathHint: pending.transcriptPathHint });
+    if (captured) {
+        discardPendingScrapedResponse(pollerKey);
+        (0, response_dedup_1.settleStructuredHistoryRecheck)(pollerKey);
+        logger.info('pending-scrape-superseded', {
+            worktreeId: pending.worktreeId,
+            cliToolId: pending.cliToolId,
+            instanceId: pending.instanceId,
+            heldForMs: Date.now() - pending.timestamp.getTime(),
+        });
+        return;
+    }
+    flushPendingScrapedResponse(pollerKey, 'hold-expired');
+}

package/dist/server/src/lib/polling/prompt-dedup-state.js

@@ -39,9 +39,9 @@ exports.getPromptDedupSkips = getPromptDedupSkips;
 exports.renamePromptDedupSkips = renamePromptDedupSkips;
 exports.clearPromptDedupSkips = clearPromptDedupSkips;
 const auto_yes_state_1 = require("../../lib/auto-yes-state");
+const global_state_1 = require("../global-state");
 /** compositeKey -> running tally of suppressed prompts for that session. */
-const promptDedupSkips = globalThis.__promptDedupSkips ??
-    (globalThis.__promptDedupSkips = new Map());
+const promptDedupSkips = (0, global_state_1.getOrInitGlobal)('__promptDedupSkips', () => new Map());
 /**
  * Count one prompt the dedup guard suppressed for `instanceId`.
  *

package/dist/server/src/lib/polling/prompt-dedup.js

@@ -13,8 +13,8 @@ exports.clearPromptHashCache = clearPromptHashCache;
 exports.renamePromptHashCacheKey = renamePromptHashCacheKey;
 exports.normalizePromptForDedup = normalizePromptForDedup;
 const crypto_1 = require("crypto");
-const promptHashCache = globalThis.__promptHashCache ??
-    (globalThis.__promptHashCache = new Map());
+const global_state_1 = require("../global-state");
+const promptHashCache = (0, global_state_1.getOrInitGlobal)('__promptHashCache', () => new Map());
 /**
  * Check if the given prompt content is a duplicate of the last saved prompt
  * for the same pollerKey. If not a duplicate, updates the cache.

package/dist/server/src/lib/polling/response-checker-dialog-gate.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * The two gates a prompt candidate passes before it is treated as a live
+ * dialog: agy's permission receipt and the tool's own dialog rules
+ * (Issue #3374 split from response-checker.ts).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWithheldForWantOfReceipt = isWithheldForWantOfReceipt;
+exports.isNumberedDialogVouched = isNumberedDialogVouched;
+const logger_1 = require("../../lib/logger");
+const logger = (0, logger_1.createLogger)('response-poller');
+const antigravity_permission_receipts_1 = require("./antigravity-permission-receipts");
+// Issue #2457: the same rollout table, `hasDialogRules` cross-check and
+// `detectDialog` seam Auto-Yes reads, reached through the presence helper rather
+// than through `evaluateAutoYesDialogGate` — see `isNumberedDialogVouched`.
+const auto_yes_dialog_gate_1 = require("./auto-yes-dialog-gate");
+/**
+ * Should an agy frame that reads as a prompt be treated as no prompt because
+ * agy asked CommandMate about no tool call lately? (Issue #2849)
+ *
+ * agy asks (`PreToolUse`) before it draws ANY approval dialog and waits for the
+ * reply, so a dialog that is really open follows a question a moment before it,
+ * and one that is only quoted in a reply follows nothing. The frame carries no
+ * tool name, so the check is time-only.
+ *
+ * Not gated (false) when there is no scope: a caller that only shows the frame —
+ * the status API, the response poller's stored `prompt` row, the notification —
+ * must keep showing a real dialog on a machine whose hook is not installed or
+ * did not reach us. Only the caller that ANSWERS the frame opts in, because for
+ * it a missed answer costs a human a keystroke and a wrong one is sent as an
+ * utterance nobody asked for.
+ *
+ * `debug`, not `info`: the poller re-reads a static pane every 2s, so a
+ * quotation left on screen would print this on every tick.
+ */
+function isWithheldForWantOfReceipt(scope) {
+    if (scope === undefined)
+        return false;
+    if ((0, antigravity_permission_receipts_1.hasRecentAntigravityPermissionReceipt)(scope.worktreeId, 'antigravity', scope.instanceId))
+        return false;
+    logger.debug('antigravity-dialog-no-recent-receipt', {
+        worktreeId: scope.worktreeId,
+        instanceId: scope.instanceId ?? 'antigravity',
+    });
+    return true;
+}
+/**
+ * Is the generic parser's numbered-list candidate a dialog the tool vouches for?
+ * (Issue #2457)
+ *
+ * ## The candidate this removes
+ *
+ * `detectPrompt` classifies a frame as `multiple_choice` from the ROWS alone,
+ * and for Claude `buildDetectPromptOptions` returns
+ * `requireDefaultIndicator: false` — so a reply that happens to answer in
+ * Markdown ("1. …  2. …  3. …") is a candidate with no `❯` anywhere near it.
+ * Every one of those was stored as a `prompt` message, and the chat surface drew
+ * a tool-approval chip over an ordinary answer.
+ *
+ * ## Why the whole frame, and only the frame
+ *
+ * `detectDialog` decides by POSITION and CHROME — where the option block sits
+ * relative to the transcript tail, what (if anything) is drawn under it. None of
+ * that survives being handed the extracted response, the question string or a
+ * tail window, so the caller passes the same capture the candidate came off, as
+ * captured: `evaluateDialogPresence` documents why the box drawing must still be
+ * on it.
+ *
+ * ## What a `false` means downstream
+ *
+ * Not "there is no output here" — only "this is not a prompt". The caller falls
+ * through to the ordinary completion/partial reading, so a real reply is still
+ * saved by the normal path and a half-written one still reports
+ * `isComplete: false`.
+ *
+ * @param cliToolId - CLI tool the frame came from
+ * @param promptDetection - What the generic parser (or a tool reader) answered
+ * @param frame - The whole capture this tick made, as captured
+ * @returns True when the candidate may be treated as a live prompt
+ */
+function isNumberedDialogVouched(cliToolId, promptDetection, frame) {
+    const presence = (0, auto_yes_dialog_gate_1.evaluateDialogPresence)(cliToolId, promptDetection.promptData?.type, frame);
+    if (presence.present)
+        return true;
+    // `debug`, not `info`: the poller re-reads a static idle pane every 2s, so a
+    // reply carrying a numbered list would print this on every tick for as long as
+    // it stays on screen. The suppression is not silent where it matters — nothing
+    // is stored, so History simply shows the reply the ordinary path saves.
+    logger.debug('prompt-candidate-not-vouched', {
+        cliToolId,
+        promptType: promptDetection.promptData?.type,
+        gateMode: presence.mode,
+    });
+    return false;
+}

package/dist/server/src/lib/polling/response-checker-extraction-result.js

@@ -0,0 +1,50 @@
+"use strict";
+/**
+ * The result shape of `extractResponse` and its two shared builders
+ * (Issue #3374 split from response-checker.ts).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.incompleteResult = incompleteResult;
+exports.buildPromptExtractionResult = buildPromptExtractionResult;
+const cli_patterns_1 = require("../../lib/detection/cli-patterns");
+const response_extractor_1 = require("../response-extractor");
+/**
+ * Creates an incomplete extraction result with empty response.
+ * Centralizes the repeated pattern of returning an in-progress/incomplete state.
+ *
+ * @param lineCount - Current line count for state tracking
+ * @returns ExtractionResult with empty response and isComplete: false
+ */
+function incompleteResult(lineCount) {
+    return { response: '', isComplete: false, lineCount };
+}
+/**
+ * Build a complete ExtractionResult for a detected prompt.
+ *
+ * Shared between Claude early prompt detection (section 3-4, site 1) and
+ * fallback prompt detection (section 3-4, site 2) in extractResponse().
+ * Applies resolveExtractionStartIndex() to limit extraction to lastCapturedLine
+ * onwards, then strips ANSI codes for safe DB storage (Stage 4 MF-001).
+ *
+ * @param lines - The trimmed tmux buffer lines array
+ * @param lastCapturedLine - Number of lines previously captured
+ * @param totalLines - Total line count in the buffer
+ * @param bufferReset - External buffer reset flag
+ * @param cliToolId - CLI tool identifier
+ * @param findRecentUserPromptIndex - Callback to locate the most recent user prompt
+ * @param promptDetection - Prompt detection result to carry on the extraction result
+ * @param captureWindowSaturated - True when the capture was clipped by the capture window (#1670)
+ * @returns ExtractionResult with isComplete: true and ANSI-stripped response
+ */
+function buildPromptExtractionResult(lines, lastCapturedLine, totalLines, bufferReset, cliToolId, findRecentUserPromptIndex, promptDetection, captureWindowSaturated = false) {
+    const startIndex = (0, response_extractor_1.resolveExtractionStartIndex)(lastCapturedLine, totalLines, bufferReset, cliToolId, findRecentUserPromptIndex, captureWindowSaturated);
+    const extractedLines = lines.slice(startIndex);
+    return {
+        response: (0, cli_patterns_1.stripAnsi)(extractedLines.join('\n')),
+        isComplete: true,
+        lineCount: totalLines,
+        promptDetection,
+        bufferReset,
+        captureWindowSaturated,
+    };
+}