commandmate 0.44.1 → 0.44.3

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

@@ -49,8 +49,8 @@ exports.claimStructuredHistoryRecheck = claimStructuredHistoryRecheck;
 exports.clearResponseHashCache = clearResponseHashCache;
 exports.renameResponseHashCacheKey = renameResponseHashCacheKey;
 const crypto_1 = require("crypto");
-const responseHashCache = globalThis.__responseHashCache ??
-    (globalThis.__responseHashCache = new Map());
+const global_state_1 = require("../global-state");
+const responseHashCache = (0, global_state_1.getOrInitGlobal)('__responseHashCache', () => new Map());
 /**
  * In-memory cache: pollerKey -> ticks still to wait before the transcript reader
  * is asked again (Issue #2399). Absence means nothing is owed.
@@ -58,8 +58,7 @@ const responseHashCache = globalThis.__responseHashCache ??
  * On `globalThis` for the same reason `responseHashCache` is, and populated and
  * cleared at exactly the same moments — see the module comment.
  */
-const structuredHistoryRecheckCache = globalThis.__structuredHistoryRecheckCache ??
-    (globalThis.__structuredHistoryRecheckCache = new Map());
+const structuredHistoryRecheckCache = (0, global_state_1.getOrInitGlobal)('__structuredHistoryRecheckCache', () => new Map());
 /**
  * How many duplicate ticks separate two asks of the transcript reader (#2399).
  *

package/dist/server/src/lib/polling/response-poller-constants.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * Constants of the response poller that import nothing (Issue #3374 split from
+ * response-poller-core.ts, so the modules split out of response-checker.ts can
+ * read them without importing response-poller-core).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GEMINI_LOADING_INDICATORS = void 0;
+/**
+ * Gemini auth/loading state indicators that should not be treated as complete responses.
+ * Braille spinner characters are shared with CLAUDE_SPINNER_CHARS in cli-patterns.ts.
+ * Extracted to module level for clarity and to avoid re-creation on each call.
+ */
+exports.GEMINI_LOADING_INDICATORS = [
+    'Waiting for auth',
+    '\u280b', '\u2819', '\u2839', '\u2838', '\u283c', '\u2834', '\u2826', '\u2827', '\u2807', '\u280f',
+];

package/dist/server/src/lib/polling/response-poller-core.js

@@ -17,6 +17,9 @@ const response_dedup_1 = require("./response-dedup");
 const prompt_dedup_state_1 = require("./prompt-dedup-state");
 const response_checker_1 = require("./response-checker");
 const terminal_broadcast_1 = require("../../lib/realtime/terminal-broadcast");
+const terminal_session_ownership_1 = require("../../lib/realtime/terminal-session-ownership");
+const session_name_1 = require("../../lib/cli-tools/session-name");
+const global_state_1 = require("../global-state");
 const logger = (0, logger_1.createLogger)('response-poller');
 // ============================================================================
 // Constants
@@ -43,26 +46,22 @@ exports.MAX_POLLING_DURATION = 30 * 60 * 1000;
  * goes ahead without it.
  */
 exports.STALLED_TICK_TIMEOUT = 60 * 1000;
-/**
- * Gemini auth/loading state indicators that should not be treated as complete responses.
- * Braille spinner characters are shared with CLAUDE_SPINNER_CHARS in cli-patterns.ts.
- * Extracted to module level for clarity and to avoid re-creation on each call.
- */
-exports.GEMINI_LOADING_INDICATORS = [
-    'Waiting for auth',
-    '\u280b', '\u2819', '\u2839', '\u2838', '\u283c', '\u2834', '\u2826', '\u2827', '\u2807', '\u280f',
-];
-const coordinator = globalThis.__responsePollerCoordinator ??
-    (globalThis.__responsePollerCoordinator = {
-        activePollers: new Map(),
-        pollingStartTimes: new Map(),
-        owners: new Map(),
-        running: new Map(),
-        pendingRestart: new Map(),
-        ownerStorage: new async_hooks_1.AsyncLocalStorage(),
-        generationCounter: 0,
-        pausedOnPrompt: new Set(),
-    });
+// Issue #3374: lives in `./response-poller-constants`, a module that imports
+// nothing, so `response-checker-extraction-steps` can read it without entering
+// the response-poller-core ⇄ response-checker cycle. Re-exported under the name
+// it had here, so no import site has to change.
+var response_poller_constants_1 = require("./response-poller-constants");
+Object.defineProperty(exports, "GEMINI_LOADING_INDICATORS", { enumerable: true, get: function () { return response_poller_constants_1.GEMINI_LOADING_INDICATORS; } });
+const coordinator = (0, global_state_1.getOrInitGlobal)('__responsePollerCoordinator', () => ({
+    activePollers: new Map(),
+    pollingStartTimes: new Map(),
+    owners: new Map(),
+    running: new Map(),
+    pendingRestart: new Map(),
+    ownerStorage: new async_hooks_1.AsyncLocalStorage(),
+    generationCounter: 0,
+    pausedOnPrompt: new Set(),
+}));
 // The coordinator object outlives a module reload (that is the point of putting
 // it on `globalThis`), so a field added after the object was first built has to
 // be filled in on an object an older evaluation created — `next dev` keeps
@@ -256,6 +255,41 @@ async function runPollTick(target, owner) {
             stopPollingByKey(pollerKey);
             return;
         }
+        // Issue #3334: whose session is it, asked before anything reads it. The
+        // chain was started by a send the route had checked, but it keeps reading
+        // by NAME: if the session ends mid-poll and another CommandMate server
+        // starts one under the same name (#2865), `checkForResponse` would capture
+        // that server's pane and save its reply / prompt into this worktree's chat
+        // and history, and the push below would show it. Such a tick reads,
+        // records and pushes nothing, and the chain ends — the same way
+        // `checkForResponse` ends it when the session is not running (or the
+        // worktree row is gone), since from this server's side the session it
+        // was watching is gone.
+        let refusal;
+        try {
+            refusal = await (0, terminal_session_ownership_1.findTerminalSessionRefusal)(target.worktreeId, (0, session_name_1.resolveSessionName)(target.cliToolId, target.worktreeId, target.instanceId));
+        }
+        catch (error) {
+            // Could not tell whose it is: this tick reads nothing, and the chain
+            // tries again on the next one rather than ending a turn over a hiccup.
+            logger.error('poller:ownership-check-failed', {
+                pollerKey,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            if (!owner.superseded && !owner.stopped) {
+                scheduleTick(target, owner);
+            }
+            return;
+        }
+        if (refusal !== null) {
+            logger.warn('poller:session-refused', { pollerKey, generation: owner.generation, refusal });
+            // A chain retired while this check was in flight must not stop the one
+            // that replaced it (Issue #2223).
+            if (!owner.superseded && !owner.stopped) {
+                stopPollingByKey(pollerKey);
+            }
+            return;
+        }
         // Check for response
         let recorded = false;
         try {

package/dist/server/src/lib/polling/startup-screen.js

@@ -0,0 +1,142 @@
+"use strict";
+/**
+ * Is this pane still on its tool's startup screen? (Issue #3293)
+ *
+ * codex and vibe-local are the two tools whose saved reply is "the rows past the
+ * cursor": the response poller (`extractResponse`) and the pre-send flush
+ * (`savePendingAssistantResponse`) both start reading at `lastCapturedLine`,
+ * which is 0 for a new session. Their startup screen is a complete, idle frame —
+ * input box drawn, nothing working — so both paths read the banner as a finished
+ * reply and History opened with an assistant row holding the version, the cwd
+ * and the model, before the operator had said anything.
+ *
+ * The rule is the one #1897 (copilot), #2247 (claude) and #2250 (command-code)
+ * converged on: every prompt is echoed into the transcript, and the startup
+ * screen has none. It is asked of the WHOLE pane, never of the rows past the
+ * cursor — those legitimately hold a reply whose echo sits above the cursor.
+ *
+ * Both halves are required, and the answer is `false` when either is missing:
+ *
+ *  - the tool's input box is on the pane. A frame it cannot be found on is not
+ *    known to be an idle screen, and the reading the two paths had before stands;
+ *  - no echoed user message is above it.
+ *
+ * One function for the two paths, so the poller and the flush cannot disagree
+ * about the same pane. Each tool keeps its own reader, as the chrome readers in
+ * `response-checker` do: the echo is a tool-specific measurement.
+ *
+ * ## An echo that is missing because it has left the pane
+ *
+ * "No echo" is only evidence of "no turn" while every echo since the session
+ * started is still in the capture. Two things break that, and each tool is
+ * covered for the one it can meet:
+ *
+ *  - **the capture window clipped the scrollback** (#1670). Callers do not ask
+ *    on such a capture: the echo of a turn longer than the window has scrolled
+ *    out of it, and a startup screen is never that tall. This is all vibe-local
+ *    needs — it draws inline and keeps its scrollback.
+ *  - **the tool keeps no scrollback at all.** codex 0.160.0 draws in the
+ *    alternate screen (`#{alternate_on}` 1, `#{history_size}` 0) with the
+ *    composer pinned to row 996; the 0.157.1 captures have the same pinned
+ *    composer. The capture is 1000 rows however long the transcript is, the
+ *    window guard never fires, and a turn longer than the pane pushes its own
+ *    echo off the top. Such a frame has the composer and no echo above it, and
+ *    it is a finished reply. So codex is asked for a third thing, which only
+ *    its startup screen has: the banner row (see {@link CODEX_BANNER_ROW_PATTERN}).
+ *
+ * @module lib/polling/startup-screen
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isStartupScreenWithoutUserEcho = isStartupScreenWithoutUserEcho;
+const cli_patterns_1 = require("../detection/cli-patterns");
+/**
+ * vibe-local's prompt row, `ctx:N% ❯`, at column 0.
+ *
+ * Measured on vibe-local 1.3.3 (`tests/fixtures/startup-screen-3293/`): the row
+ * is drawn once per prompt and stays in the scrollback with what was typed
+ * after it, so a submitted message and the input box share this shape.
+ */
+const VIBE_LOCAL_PROMPT_ROW_PATTERN = /^ctx:\d+%\s*[>❯]/;
+/** The same row with text after the glyph: an echoed message, or one being typed. */
+const VIBE_LOCAL_PROMPT_ROW_WITH_TEXT_PATTERN = /^ctx:\d+%\s*[>❯]\s*\S/;
+/**
+ * codex's banner row, `>_ OpenAI Codex (v0.160.0)`.
+ *
+ * The first thing codex draws and the top of its transcript: every echo is
+ * printed below it, so it leaves a pane whose transcript has outgrown it before
+ * the echo of that turn can. "Banner above the composer, no echo" is therefore
+ * a pane that has not had a turn, and "no banner, no echo" is one that has had
+ * a turn longer than itself — measured on 0.160.0, where the banner is not
+ * pinned and scrolls off with the transcript
+ * (`tests/fixtures/startup-screen-3293/codex-0.160.0-overflow-interrupted.txt`).
+ *
+ * The same text in every capture this repository holds, 0.146.0 to 0.160.0 —
+ * inside the box earlier versions drew around it
+ * (`│ >_ OpenAI Codex (v0.153.2) … │`) and on a row of its own on 0.160.0. A
+ * codex that words its banner differently is not read as a startup screen,
+ * which is the direction that saves the banner again rather than the one that
+ * drops a reply.
+ */
+const CODEX_BANNER_ROW_PATTERN = />_ OpenAI Codex \(v\d/;
+/**
+ * codex: the composer is located, no transcript echo is above it, and the
+ * banner is.
+ *
+ * `findCodexChromeStart` reads the composer by its SGR attributes (#2310), so a
+ * message typed into it and not yet sent is still the composer, not an echo.
+ */
+function isCodexStartupScreen(lines) {
+    const chromeStart = (0, cli_patterns_1.findCodexChromeStart)(lines);
+    if (chromeStart < 0)
+        return false;
+    if ((0, cli_patterns_1.findCodexUserEchoIndex)(lines, chromeStart, lines.length, true) >= 0)
+        return false;
+    for (let i = 0; i < chromeStart; i++) {
+        if (CODEX_BANNER_ROW_PATTERN.test((0, cli_patterns_1.stripAnsi)(lines[i])))
+            return true;
+    }
+    return false;
+}
+/**
+ * vibe-local: a prompt row is on the pane, and none of them holds text.
+ *
+ * No banner test here. vibe-local draws inline (`#{alternate_on}` 0, the
+ * history grows with every turn — measured on 1.3.3), so its echoes stay in the
+ * capture until the window clips it, and the callers' guard covers that.
+ *
+ * A row with text is read as an echo even while it is still the input box. The
+ * row alone cannot tell the two apart: while a reply is being printed the newest
+ * prompt row IS the echo, and reading it as a message not yet sent would answer
+ * "no turn yet" and move the cursor past the reply under it.
+ */
+function isVibeLocalStartupScreen(lines) {
+    let hasPromptRow = false;
+    for (const rawLine of lines) {
+        const line = (0, cli_patterns_1.stripAnsi)(rawLine);
+        if (!VIBE_LOCAL_PROMPT_ROW_PATTERN.test(line))
+            continue;
+        if (VIBE_LOCAL_PROMPT_ROW_WITH_TEXT_PATTERN.test(line))
+            return false;
+        hasPromptRow = true;
+    }
+    return hasPromptRow;
+}
+/**
+ * Does the pane show the tool's input box with no user message echoed yet?
+ *
+ * @param cliToolId - The tool the capture came from
+ * @param lines - The whole capture, ANSI intact (codex's reader needs the attributes)
+ * @returns True for a codex or vibe-local pane that has not had a turn; false for
+ *   every other tool, whenever the input box cannot be located, and for a codex
+ *   pane whose banner is not above it
+ */
+function isStartupScreenWithoutUserEcho(cliToolId, lines) {
+    switch (cliToolId) {
+        case 'codex':
+            return isCodexStartupScreen(lines);
+        case 'vibe-local':
+            return isVibeLocalStartupScreen(lines);
+        default:
+            return false;
+    }
+}

package/dist/server/src/lib/polling/structured-history-gate.js

@@ -83,6 +83,7 @@ const tool_id_3 = require("../../lib/hooks/sources/antigravity/tool-id");
 const tool_id_4 = require("../../lib/hooks/sources/command-code/tool-id");
 const registry_1 = require("../../lib/hooks/sources/registry");
 const relay_triggers_1 = require("../../lib/relay/relay-triggers");
+const global_state_1 = require("../global-state");
 const logger = (0, logger_1.createLogger)('lib/polling/structured-history-gate');
 /**
  * One in-flight capture per instance (Issue #2246).
@@ -118,7 +119,7 @@ const logger = (0, logger_1.createLogger)('lib/polling/structured-history-gate')
  * get a private copy of a module-scoped map, and a lock only one of two bundles
  * can see is not a lock.
  */
-const captureQueue = (globalThis.__structuredHistoryCaptureQueue ??= new Map());
+const captureQueue = (0, global_state_1.getOrInitGlobal)('__structuredHistoryCaptureQueue', () => new Map());
 /**
  * The last completion each instance was announced for (Issue #2443).
  *
@@ -133,7 +134,7 @@ const captureQueue = (globalThis.__structuredHistoryCaptureQueue ??= new Map());
  * and a restart that forgets it costs at most one extra announcement into a
  * relay whose own stash guard already refuses a second payload.
  */
-const announcedCompletions = (globalThis.__structuredHistoryAnnouncedCompletions ??= new Map());
+const announcedCompletions = (0, global_state_1.getOrInitGlobal)('__structuredHistoryAnnouncedCompletions', () => new Map());
 /** Forget every instance's in-flight capture and announced completion. Test seam. */
 function resetStructuredHistoryCaptureQueue() {
     captureQueue.clear();

package/dist/server/src/lib/prompt-answer-semantic.js

@@ -0,0 +1,178 @@
+"use strict";
+/**
+ * Semantic yes/no answer resolution for detected prompts (Issue #1681).
+ *
+ * `respond <wt> yes|no` used to send the raw text + Enter. Cursor-navigated
+ * multiple-choice menus (claude / antigravity) ignore typed characters, so the
+ * Enter selected the highlighted default option — `respond no` on a
+ * "1. Yes / 2. Yes, allow all / 3. No" menu approved instead of denying.
+ *
+ * This module resolves a semantic yes/no answer (or an explicit "pick the
+ * default" request) to a concrete option number BEFORE anything is sent, and
+ * refuses with {@link PromptAnswerResolutionError} when no option label can be
+ * matched, so the caller sends nothing at all instead of a stray Enter.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromptAnswerResolutionError = void 0;
+exports.hasCheckboxOptions = hasCheckboxOptions;
+exports.isMultiSelectPrompt = isMultiSelectPrompt;
+exports.parseSemanticAnswer = parseSemanticAnswer;
+exports.resolvePromptAnswer = resolvePromptAnswer;
+/**
+ * Checkbox-style multi-select options have no yes/no semantics.
+ *
+ * Issue #2755 made this the SECOND of two readings rather than the only one.
+ * Command Code's reader now strips the box off the label and reports the state
+ * as `multiSelect` / `checked`, so on that tool there is no bracket left to
+ * match and {@link isMultiSelectPrompt} is what refuses the answer. The pattern
+ * stays for every payload that still carries brackets — claude's and agy's
+ * checkbox menus reach the sender through the generic parser, which does not
+ * strip them — because dropping it here would silently reopen #1681's hole on
+ * those tools.
+ */
+const CHECKBOX_OPTION_PATTERN = /^\[[ xX\u2714]\] /;
+/**
+ * Whether any option still wears a checkbox (`[ ]`, `[x]`, `[X]`, `[✔]`).
+ *
+ * Issue #3397: the ONE reading of a checkbox label. `prompt-answer-sender`
+ * (Space→Next instead of a plain Enter) and Auto-Yes's Enter on an unreadable
+ * choice screen read it here, so the three paths agree on which lists are
+ * multi-select; the sender used to carry a narrower copy (`[ ]` / `[x]` only).
+ */
+function hasCheckboxOptions(options) {
+    return options.some(o => CHECKBOX_OPTION_PATTERN.test(o.label));
+}
+/**
+ * Whether this prompt is a checkbox question (Issue #2755).
+ *
+ * Either reading counts: the payload saying so, or a label that still wears its
+ * box. See {@link CHECKBOX_OPTION_PATTERN} for why both are needed.
+ */
+function isMultiSelectPrompt(promptData) {
+    return promptData.multiSelect === true || hasCheckboxOptions(promptData.options);
+}
+/** Labels that mean "approve" (e.g. "Yes", "Yes, allow all edits ..."). */
+const AFFIRMATIVE_LABEL_PATTERN = /^yes\b/i;
+/** Labels that mean "reject" (e.g. "No", "No, and tell Claude ...", "Deny"). */
+const NEGATIVE_LABEL_PATTERNS = [/^no\b/i, /\bdeny\b/i];
+/**
+ * Raised when an answer cannot be resolved to a concrete option. Messages are
+ * fixed strings (no user input) per SEC-003 and are safe to return to clients.
+ */
+class PromptAnswerResolutionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'PromptAnswerResolutionError';
+    }
+}
+exports.PromptAnswerResolutionError = PromptAnswerResolutionError;
+/**
+ * Parse an answer as a semantic yes/no token. Only exact tokens qualify —
+ * free text like "yes please" is NOT semantic and passes through unchanged.
+ */
+function parseSemanticAnswer(answer) {
+    const normalized = answer.trim().toLowerCase();
+    if (normalized === 'yes' || normalized === 'y')
+        return 'yes';
+    if (normalized === 'no' || normalized === 'n')
+        return 'no';
+    return null;
+}
+function isNegativeLabel(label) {
+    return NEGATIVE_LABEL_PATTERNS.some(p => p.test(label));
+}
+function isAffirmativeLabel(label) {
+    // A label matching a negative pattern never counts as affirmative
+    // (guards against future pattern overlap).
+    return AFFIRMATIVE_LABEL_PATTERN.test(label) && !isNegativeLabel(label);
+}
+function resolveSemanticOption(promptData, semantic) {
+    const options = promptData.options;
+    if (isMultiSelectPrompt(promptData)) {
+        throw new PromptAnswerResolutionError('Multi-select (checkbox) prompts cannot be answered with yes/no. Answer with the option numbers you want ticked, comma-separated (for example "1,3").');
+    }
+    const matcher = semantic === 'yes' ? isAffirmativeLabel : isNegativeLabel;
+    const matches = options.filter(o => matcher(o.label));
+    if (matches.length === 0) {
+        throw new PromptAnswerResolutionError(`No option label matches "${semantic}". Answer with an option number.`);
+    }
+    // Multiple matches (e.g. "1. Yes" / "2. Yes, allow all edits ..."): pick the
+    // lowest-numbered one — in Claude-style permission menus that is the plain,
+    // narrowest-scope choice.
+    return matches.reduce((a, b) => (a.number <= b.number ? a : b));
+}
+function resolveDefaultOption(options) {
+    // Mirrors prompt-answer-sender: when no option carries the ❯ indicator the
+    // cursor rests on option 1.
+    const def = options.find(o => o.isDefault)
+        ?? options.find(o => o.number === 1)
+        ?? options[0];
+    if (!def) {
+        throw new PromptAnswerResolutionError('The prompt has no options to select a default from.');
+    }
+    return def;
+}
+/**
+ * Resolve the request to the concrete terminal input.
+ *
+ * - `useDefault`: resolves to the default option (multiple_choice) or the
+ *   default answer (yes_no). Requires detected promptData.
+ * - semantic yes/no on a detected multiple_choice prompt: resolves the option
+ *   number by label; unresolvable labels raise instead of degrading to Enter.
+ * - semantic yes/no when detection failed but the client claims
+ *   multiple_choice: raises (option labels are unknown).
+ * - everything else (numbers, free text, yes/no on yes_no prompts) passes
+ *   through unchanged.
+ *
+ * @throws PromptAnswerResolutionError when the answer must not be sent.
+ */
+function resolvePromptAnswer(params) {
+    const { answer, useDefault, promptData, fallbackPromptType } = params;
+    if (useDefault) {
+        if (promptData?.type === 'multiple_choice') {
+            // Issue #2755: on a checkbox question the `❯` is a CURSOR, not a
+            // pre-selected answer — it says which row a key would toggle. Turning it
+            // into "the answer" ticked one box and stopped, and on a screen where the
+            // human had already ticked that box it UNticked it (`respond --default`
+            // on #2754's `multiselect-cursor-on-option-2`). Refused before anything
+            // is sent, like every other unresolvable answer here.
+            if (isMultiSelectPrompt(promptData)) {
+                throw new PromptAnswerResolutionError('Multi-select (checkbox) prompts have no default answer: the cursor marks the row a key would toggle, not a choice. Answer with the option numbers you want ticked, comma-separated (for example "1,3").');
+            }
+            const opt = resolveDefaultOption(promptData.options);
+            return {
+                input: String(opt.number),
+                resolved: { via: 'default', optionNumber: opt.number, optionLabel: opt.label },
+            };
+        }
+        if (promptData?.type === 'yes_no') {
+            if (promptData.defaultOption) {
+                return {
+                    input: promptData.defaultOption,
+                    resolved: { via: 'default', optionLabel: promptData.defaultOption },
+                };
+            }
+            throw new PromptAnswerResolutionError('The yes/no prompt declares no default option.');
+        }
+        throw new PromptAnswerResolutionError('Cannot select the default option: no active prompt was detected.');
+    }
+    const rawAnswer = answer ?? '';
+    const semantic = parseSemanticAnswer(rawAnswer);
+    if (semantic === null) {
+        return { input: rawAnswer };
+    }
+    if (promptData?.type === 'multiple_choice') {
+        const opt = resolveSemanticOption(promptData, semantic);
+        return {
+            input: String(opt.number),
+            resolved: { via: 'semantic', optionNumber: opt.number, optionLabel: opt.label },
+        };
+    }
+    // Fresh detection did not yield a multiple-choice prompt. If the client
+    // claims one, the option labels are unknown — refuse rather than let the
+    // text degrade into a bare Enter that picks the default.
+    if (!promptData && fallbackPromptType === 'multiple_choice') {
+        throw new PromptAnswerResolutionError('Cannot resolve yes/no: the prompt is multiple choice but its options could not be read.');
+    }
+    return { input: rawAnswer };
+}

package/dist/server/src/lib/prompt-answer-sender.js

@@ -17,9 +17,10 @@ const dialog_1 = require("../lib/detection/tools/command-code/dialog");
 const selection_shape_1 = require("../lib/detection/selection-shape");
 const models_1 = require("../types/models");
 const tmux_capture_cache_1 = require("./tmux/tmux-capture-cache");
+const prompt_answer_semantic_1 = require("../lib/prompt-answer-semantic");
 const cli_tool_timing_config_1 = require("../config/cli-tool-timing-config");
-/** Regex pattern to detect checkbox-style multi-select options */
-const CHECKBOX_OPTION_PATTERN = /^\[[ x]\] /;
+// Issue #3397: the checkbox reading (`hasCheckboxOptions`) lives in
+// `prompt-answer-semantic`, shared with the semantic resolver and Auto-Yes.
 /**
  * A validated SELECTION SET, as opposed to free text (Issue #2755).
  *
@@ -294,7 +295,7 @@ async function assertAnswerModeAcceptsNumber(params) {
     const frame = await readGuardFrame(params);
     if (frame === null)
         return null;
-    const dialog = detector.detectDialog((0, frame_1.normalizeFrame)(frame));
+    const dialog = detector.detectDialog((0, frame_1.normalizeFrame)(frame, params.cliToolId));
     if (dialog === null)
         return null;
     if (dialog.answerMode === TEXT_ANSWERABLE_ANSWER_MODE)
@@ -815,10 +816,10 @@ async function sendPromptAnswer(params) {
         // Multi-select prompts require: Space to toggle checkbox -> navigate to "Next" -> Enter.
         // Single-select prompts require: navigate to option -> Enter.
         // Note: multi-select detection is only possible when promptData succeeded (mcOptions available).
-        const isMultiSelect = mcOptions !== null && mcOptions.some(o => CHECKBOX_OPTION_PATTERN.test(o.label));
+        const isMultiSelect = mcOptions !== null && (0, prompt_answer_semantic_1.hasCheckboxOptions)(mcOptions);
         if (isMultiSelect && mcOptions !== null) {
             // Multi-select: toggle checkbox, then navigate to "Next" and submit
-            const checkboxCount = mcOptions.filter(o => CHECKBOX_OPTION_PATTERN.test(o.label)).length;
+            const checkboxCount = mcOptions.filter(o => (0, prompt_answer_semantic_1.hasCheckboxOptions)([o])).length;
             const keys = [
                 ...buildNavigationKeys(offset), // 1. Navigate to target option
                 'Space', // 2. Toggle checkbox

package/dist/server/src/lib/push/failure-episode-state.js

@@ -56,6 +56,7 @@ exports.UPSTREAM_FAULT_COOLDOWN_MS = void 0;
 exports.observeUpstreamFaultEdge = observeUpstreamFaultEdge;
 exports.clearUpstreamFaultEpisodes = clearUpstreamFaultEpisodes;
 const auto_yes_state_1 = require("../../lib/auto-yes-state");
+const global_state_1 = require("../global-state");
 /**
  * How long after notifying about an upstream fault this instance stays quiet
  * about upstream faults.
@@ -68,8 +69,7 @@ const auto_yes_state_1 = require("../../lib/auto-yes-state");
  * bound only governs how often the *phone* is used.
  */
 exports.UPSTREAM_FAULT_COOLDOWN_MS = 30 * 60_000;
-const states = globalThis.__upstreamFaultPushState ??
-    (globalThis.__upstreamFaultPushState = new Map());
+const states = (0, global_state_1.getOrInitGlobal)('__upstreamFaultPushState', () => new Map());
 /**
  * Record this frame's fault level and answer whether it is worth a phone.
  *

package/dist/server/src/lib/push/notification-dedup.js

@@ -18,10 +18,10 @@ exports.resetNotificationDedup = resetNotificationDedup;
 exports.shouldSendWaitingPush = shouldSendWaitingPush;
 exports.resetWaitingPushDedup = resetWaitingPushDedup;
 const crypto_1 = require("crypto");
+const global_state_1 = require("../global-state");
 /** Default suppression window: repeats of identical content within this are dropped. */
 exports.DEFAULT_DEDUP_WINDOW_MS = 30_000;
-const lastSent = globalThis.__notificationDedupLastSent ??
-    (globalThis.__notificationDedupLastSent = new Map());
+const lastSent = (0, global_state_1.getOrInitGlobal)('__notificationDedupLastSent', () => new Map());
 function contentHash(content) {
     return (0, crypto_1.createHash)('sha256').update(content).digest('hex');
 }
@@ -43,8 +43,7 @@ function shouldSendNotification(event, now = Date.now(), windowMs = exports.DEFA
 function resetNotificationDedup() {
     lastSent.clear();
 }
-const waitingSent = globalThis.__waitingPushDedup ??
-    (globalThis.__waitingPushDedup = new Map());
+const waitingSent = (0, global_state_1.getOrInitGlobal)('__waitingPushDedup', () => new Map());
 /**
  * Whether this waiting notification should be sent, recording it if so.
  *

package/dist/server/src/lib/push/prompt-card-state.js

@@ -100,6 +100,7 @@ exports.forgetPromptCardMemory = forgetPromptCardMemory;
 exports.promptCardCount = promptCardCount;
 const db_instance_1 = require("../../lib/db/db-instance");
 const logger_1 = require("../../lib/logger");
+const global_state_1 = require("../global-state");
 const logger = (0, logger_1.createLogger)('push/prompt-card-state');
 /**
  * `app_settings.key` prefix for one worktree's outstanding card.
@@ -142,8 +143,7 @@ exports.PROMPT_CARD_KEY_PREFIX = 'push_prompt_card:';
  */
 exports.PROMPT_CARD_MAX_AGE_MS = 24 * 60 * 60 * 1000;
 /** worktreeId -> epoch ms the most recent prompt card was fanned out. */
-const cards = globalThis.__promptPushCards ??
-    (globalThis.__promptPushCards = new Map());
+const cards = (0, global_state_1.getOrInitGlobal)('__promptPushCards', () => new Map());
 function keyFor(worktreeId) {
     return `${exports.PROMPT_CARD_KEY_PREFIX}${worktreeId}`;
 }

package/dist/server/src/lib/push/waiting-push-notifier.js

@@ -74,6 +74,7 @@ const prompt_push_gate_1 = require("./prompt-push-gate");
 const push_sender_1 = require("./push-sender");
 const resolution_push_notifier_1 = require("./resolution-push-notifier");
 const vapid_1 = require("./vapid");
+const global_state_1 = require("../global-state");
 const logger = (0, logger_1.createLogger)('push/waiting-notifier');
 /** How often outstanding waits are re-checked. Minute granularity is enough. */
 exports.ESCALATION_TICK_MS = 60_000;
@@ -99,11 +100,9 @@ exports.ESCALATION_TICK_MS = 60_000;
  * still notify on the edge itself.
  */
 exports.CLASSIFICATION_GRACE_MS = 8_000;
-const pending = globalThis.__waitingPushPending ??
-    (globalThis.__waitingPushPending = new Map());
+const pending = (0, global_state_1.getOrInitGlobal)('__waitingPushPending', () => new Map());
 /** Composite key -> the timer holding that wait's first notification (#2156). */
-const graceTimers = globalThis.__waitingPushGraceTimers ??
-    (globalThis.__waitingPushGraceTimers = new Map());
+const graceTimers = (0, global_state_1.getOrInitGlobal)('__waitingPushGraceTimers', () => new Map());
 /**
  * The worktree's display name, for the notification title.
  *

package/dist/server/src/lib/realtime/publisher-registry.js

@@ -63,16 +63,17 @@ exports.recordUnroutedPublish = recordUnroutedPublish;
 exports.getUnroutedPublishStats = getUnroutedPublishStats;
 exports.__resetRoomPublisherRegistryForTest = __resetRoomPublisherRegistryForTest;
 const logger_1 = require("../../lib/logger");
+const global_state_1 = require("../global-state");
 const logger = (0, logger_1.createLogger)('publisher-registry');
 /** At most one warning per minute; the rest are counted, not printed. */
 exports.UNROUTED_PUBLISH_WARN_INTERVAL_MS = 60_000;
 function unroutedState() {
-    return (globalThis.__realtimeUnroutedPublish ??= {
+    return (0, global_state_1.getOrInitGlobal)('__realtimeUnroutedPublish', () => ({
         total: 0,
         suppressed: 0,
         lastWarnedAt: null,
         operations: {},
-    });
+    }));
 }
 /**
  * Claim ownership of the process's rooms.