commandmate 0.44.2 → 0.44.3

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