commandmate 0.44.2 → 0.44.3

package/dist/server/src/lib/hooks/sources/transcript-history.js

@@ -0,0 +1,262 @@
+"use strict";
+/**
+ * Helpers the per-tool transcript `history.ts` modules share.
+ *
+ * Each of these was written out once per tool with only the turn type's name
+ * differing. The turn type is reduced to the one field these read.
+ *
+ * @module lib/hooks/sources/transcript-history
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAssistantTimestampMs = resolveAssistantTimestampMs;
+exports.nextTurnOpensAt = nextTurnOpensAt;
+exports.isReadableFile = isReadableFile;
+exports.selectUnwrittenTurns = selectUnwrittenTurns;
+exports.resolveSessionIdFromEvents = resolveSessionIdFromEvents;
+exports.acceptPathUnderRoot = acceptPathUnderRoot;
+exports.growTurnRowTo = growTurnRowTo;
+exports.refreshTurnRowsTo = refreshTurnRowsTo;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+/**
+ * When the assistant row for this turn is dated.
+ *
+ * **The turn's LAST assistant record, not its prompt (Issue #2273).** #2121
+ * dated the reply by the prompt record's clock so that a row written a poll late
+ * still sorted where the conversation put it, and #2196 moved it one millisecond
+ * on so that `groupMessagesIntoPairs` — which orders by timestamp and nothing
+ * else — could never return the answer above the question. Both properties
+ * survive: `earliest` is a floor this never goes under.
+ *
+ * What neither accounted for is the row that lands BETWEEN the prompt and the
+ * reply. A tool approval is written when the dialog appears, seconds into the
+ * turn, and the chat surface orders its rows by timestamp — so a reply dated at
+ * the turn's start draws ABOVE an approval that really happened before it. The
+ * measured case is in the Issue: prompt `04:49:50.989Z`, reply `04:49:54.000Z`,
+ * approval `04:49:57.513Z`, rendered as question → answer → approval.
+ *
+ * The turn's last assistant record is the moment the reply was finished, so
+ * everything the turn produced on the way sorts before it. `lastRecordAt` is 0
+ * when the window held no timestamped assistant record for the turn, and the row
+ * is then dated exactly where #2196 put it.
+ *
+ * `nextTurnOpensAt` is the ceiling. The next turn's prompt row may be a `/send`
+ * row written while THIS turn was still running — a queued prompt — and a reply
+ * that overtook it would be paired with the wrong question.
+ *
+ * @param lastRecordAt - Epoch ms of the turn's last assistant record, or 0
+ * @param nextTurnOpensAt - Epoch ms of the next turn's user row, or null when
+ *   this is the newest turn in the window
+ */
+function resolveAssistantTimestampMs(turn, userRow, lastRecordAt = 0, nextTurnOpensAt = null) {
+    const earliest = userRow.timestampMs === null
+        ? turn.startedAt
+        : Math.max(turn.startedAt, userRow.timestampMs + 1);
+    const latest = nextTurnOpensAt === null ? Number.POSITIVE_INFINITY : nextTurnOpensAt - 1;
+    return Math.max(earliest, Math.min(lastRecordAt, latest));
+}
+/**
+ * The instant the next pending turn's prompt row carries, or null (Issue #2273).
+ *
+ * The user row's own timestamp when there is one, because that is what History
+ * sorts on and it can be EARLIER than the turn's start — an adopted `/send` row
+ * was written when CommandMate handed the text to the pane, which for a queued
+ * prompt is while the previous turn was still running. The turn's start is the
+ * fallback for a turn that produced no row at all.
+ */
+function nextTurnOpensAt(turns, userRows, index) {
+    const next = turns[index + 1];
+    if (!next)
+        return null;
+    return userRows[index + 1]?.timestampMs ?? next.startedAt;
+}
+async function isReadableFile(path) {
+    try {
+        return (await (0, promises_1.stat)(path)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The turns still to write: search backwards from the newest turn for one that
+ * is already a row, and take everything after it (Issue #2246).
+ *
+ * Record order and never a timestamp. A window with no anchor answers with the
+ * newest turn alone. The tools differ only in how a turn's request id is built.
+ *
+ * @param turns - Every turn in the window, oldest first
+ * @param requestIdOf - The request id the tool records a turn's user row under
+ */
+async function selectUnwrittenTurns(target, turns, requestIdOf) {
+    const [{ getDbInstance }, { findMessageByRequestId }] = await Promise.all([
+        Promise.resolve().then(() => __importStar(require('../../../lib/db/db-instance'))),
+        Promise.resolve().then(() => __importStar(require('../../../lib/db'))),
+    ]);
+    const db = getDbInstance();
+    for (let index = turns.length - 1; index >= 0; index -= 1) {
+        const requestId = requestIdOf(turns[index]);
+        if (!findMessageByRequestId(db, target.worktreeId, requestId))
+            continue;
+        return {
+            turns: turns.slice(index + 1),
+            previousStartedAt: turns[index].startedAt,
+            anchored: true,
+        };
+    }
+    return {
+        turns: turns.slice(-1),
+        previousStartedAt: turns.length > 1 ? turns[turns.length - 2].startedAt : 0,
+        anchored: false,
+    };
+}
+/**
+ * The session id this instance's transcript is under, or null.
+ *
+ * Reads the structured event state first and falls back to the latched value.
+ * The import is dynamic so that `agent-event-state`'s module graph does not
+ * become a static dependency of the poller.
+ *
+ * @param pointers - The tool's latched session ids, keyed by `key`
+ * @param key - This instance's key in `pointers`
+ * @param logger - The calling tool's logger
+ * @param failureEvent - The event name the tool logs when the state module is unreachable
+ */
+async function resolveSessionIdFromEvents(target, pointers, key, logger, failureEvent) {
+    try {
+        const { getLastAgentEvent } = await Promise.resolve().then(() => __importStar(require('../../../lib/session/agent-event-state')));
+        const sessionId = getLastAgentEvent(target.worktreeId, target.cliToolId, target.instanceId)?.sessionId;
+        if (typeof sessionId === 'string' && sessionId.length > 0) {
+            pointers.set(key, sessionId);
+            return sessionId;
+        }
+    }
+    catch (error) {
+        // A state module that cannot be reached is one that knows no session id.
+        logger.debug(failureEvent, {
+            worktreeId: target.worktreeId,
+            instanceId: target.instanceId ?? target.cliToolId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+    return pointers.get(key) ?? null;
+}
+/**
+ * A path named by something other than the tool's module, accepted only if it
+ * ends in `extension`, carries no NUL and is under `rootDir`.
+ *
+ * Containment is checked on the *resolved* path so that `..` cannot climb out.
+ *
+ * @returns The resolved path, or null when it is not acceptable
+ */
+function acceptPathUnderRoot(rootDir, extension, candidate) {
+    if (!candidate.endsWith(extension))
+        return null;
+    if (candidate.includes('\0'))
+        return null;
+    const root = (0, path_1.resolve)(rootDir);
+    const resolved = (0, path_1.resolve)(candidate);
+    if (resolved !== root && !resolved.startsWith(root + path_1.sep))
+        return null;
+    return resolved;
+}
+/**
+ * Replace a saved row whose body has since grown (Issue #2264).
+ *
+ * Strictly longer, never merely different; `message_updated`, never `message`.
+ *
+ * @param updatedEvent - The event name the tool logs on replacement
+ * @returns Whether the row was replaced
+ */
+async function growTurnRowTo(target, existing, rendered, path, logger, updatedEvent) {
+    const instanceId = target.instanceId ?? target.cliToolId;
+    // No `typeof previous !== 'string'` guard, unlike antigravity/history.ts:
+    // `chat_messages.content` is `TEXT NOT NULL`, so it is always a string here.
+    const previousLength = existing.content.length;
+    if (rendered.body.length <= previousLength)
+        return false;
+    const [{ getDbInstance }, { updateMessageContent }, { broadcastMessage }] = await Promise.all([
+        Promise.resolve().then(() => __importStar(require('../../../lib/db/db-instance'))),
+        Promise.resolve().then(() => __importStar(require('../../../lib/db'))),
+        Promise.resolve().then(() => __importStar(require('../../../lib/ws-server'))),
+    ]);
+    updateMessageContent(getDbInstance(), existing.id, rendered.body);
+    broadcastMessage('message_updated', {
+        worktreeId: target.worktreeId,
+        message: { ...existing, content: rendered.body },
+    });
+    logger.info(updatedEvent, {
+        worktreeId: target.worktreeId,
+        instanceId,
+        sessionId: rendered.sessionId,
+        requestId: existing.requestId,
+        path,
+        previousLength,
+        bodyLength: rendered.body.length,
+        textBlocks: rendered.textBlocks,
+        toolBlocks: rendered.toolBlocks,
+    });
+    return true;
+}
+/**
+ * Re-read the newest already-written turns and grow the short ones (#2264).
+ *
+ * Turns that are still open are skipped; the database is asked before the turn
+ * is rendered.
+ *
+ * @param candidates - Already-written turns, oldest first
+ * @returns How many rows were replaced
+ */
+async function refreshTurnRowsTo(target, candidates, path, tool) {
+    if (candidates.length === 0)
+        return 0;
+    const [{ getDbInstance }, { findMessageByRequestId }] = await Promise.all([
+        Promise.resolve().then(() => __importStar(require('../../../lib/db/db-instance'))),
+        Promise.resolve().then(() => __importStar(require('../../../lib/db'))),
+    ]);
+    const db = getDbInstance();
+    let updated = 0;
+    for (const turn of candidates) {
+        if (!tool.isWritable(turn))
+            continue;
+        const existing = findMessageByRequestId(db, target.worktreeId, tool.requestIdOf(turn));
+        if (!existing)
+            continue;
+        if (await tool.grow(target, existing, tool.render(turn), path))
+            updated += 1;
+    }
+    return updated;
+}

package/dist/server/src/lib/hooks/sources/turn-body.js

@@ -68,6 +68,9 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TURN_REASONING_LABEL = exports.TURN_TOOL_LOG_LABEL = void 0;
+exports.collapseToLine = collapseToLine;
+exports.boundDetail = boundDetail;
+exports.truncateTurnBody = truncateTurnBody;
 exports.separateTurnBody = separateTurnBody;
 /**
  * The bold first line of the folded tool section.
@@ -89,6 +92,34 @@ exports.TURN_TOOL_LOG_LABEL = 'Tool calls';
  * `components/worktree/ChatMessageBubble`.
  */
 exports.TURN_REASONING_LABEL = 'Thinking';
+/**
+ * A tool title on one line.
+ *
+ * A `bash` title is the command, and a heredoc puts newlines in it. Left alone
+ * they would end the list item and turn the rest of the command into body text.
+ */
+function collapseToLine(value) {
+    return value.replace(/\s+/g, ' ').trim();
+}
+/**
+ * A tool detail cut to `max` characters, the last one being `…`.
+ *
+ * The cap is each reader's own constant; the cut is the same in all of them.
+ */
+function boundDetail(value, max) {
+    return value.length <= max ? value : `${value.slice(0, max - 1)}…`;
+}
+/**
+ * A turn body cut to `max` characters, the tail being `marker`.
+ *
+ * The cap and the marker are each reader's own constants; the cut is the same
+ * in all of them.
+ */
+function truncateTurnBody(body, max, marker) {
+    if (body.length <= max)
+        return body;
+    return body.slice(0, max - marker.length) + marker;
+}
 /**
  * Put one block inside a blockquote, line by line.
  *

package/dist/server/src/lib/hooks/tool-input-normalization-state.js

@@ -33,9 +33,9 @@ exports.recordToolInputNormalization = recordToolInputNormalization;
 exports.getLastToolInputNormalization = getLastToolInputNormalization;
 exports.clearToolInputNormalizations = clearToolInputNormalizations;
 const auto_yes_state_1 = require("../../lib/auto-yes-state");
+const global_state_1 = require("../global-state");
 /** compositeKey -> the most recent normalisation for that session. */
-const lastNormalizations = globalThis.__toolInputNormalizations ??
-    (globalThis.__toolInputNormalizations = new Map());
+const lastNormalizations = (0, global_state_1.getOrInitGlobal)('__toolInputNormalizations', () => new Map());
 /**
  * Record that `instanceId`'s last permission request arrived in a shape this
  * server had to rewrite before it could judge it.

package/dist/server/src/lib/polling/antigravity-permission-receipts.js

@@ -43,6 +43,7 @@ exports.recordAntigravityPermissionReceipt = recordAntigravityPermissionReceipt;
 exports.hasRecentAntigravityPermissionReceipt = hasRecentAntigravityPermissionReceipt;
 exports.resetAntigravityPermissionReceiptsForTests = resetAntigravityPermissionReceiptsForTests;
 const auto_yes_state_1 = require("../../lib/auto-yes-state");
+const global_state_1 = require("../global-state");
 /**
  * How long after a `PreToolUse` question a dialog still counts as its dialog.
  *
@@ -53,8 +54,7 @@ const auto_yes_state_1 = require("../../lib/auto-yes-state");
  * cover it.
  */
 exports.ANTIGRAVITY_PERMISSION_RECEIPT_WINDOW_MS = 8_000;
-const receipts = globalThis.__antigravityPermissionReceipts ??
-    (globalThis.__antigravityPermissionReceipts = new Map());
+const receipts = (0, global_state_1.getOrInitGlobal)('__antigravityPermissionReceipts', () => new Map());
 /**
  * How long an entry is kept before it is dropped on the next write.
  *

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

@@ -0,0 +1,142 @@
+"use strict";
+/**
+ * Auto-Yes's Enter record and the session epoch it belongs to (Issue #3397).
+ *
+ * Split out of `./auto-yes-enter-fallback` so that this — the part a session's
+ * lifecycle has to touch — imports nothing from detection. `beginAgentSession`
+ * (every tool's `startSession`, on the creation path) calls
+ * {@link beginEnterFallbackSession}: a new process on the same instance key is
+ * a new screen history, and an Enter sent to the previous process's dialog must
+ * neither be published against the new one (`currentPrompt: true` for the same
+ * question) nor keep the poller from answering it (`enterFallbackSentKey`).
+ *
+ * @module lib/polling/auto-yes-enter-fallback-state
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enterFallbackScreenKey = enterFallbackScreenKey;
+exports.recordEnterFallbackSent = recordEnterFallbackSent;
+exports.recordEnterFallbackNoEffect = recordEnterFallbackNoEffect;
+exports.getLastEnterFallback = getLastEnterFallback;
+exports.publishEnterFallback = publishEnterFallback;
+exports.forgetEnterFallback = forgetEnterFallback;
+exports.forgetEnterFallbacksByWorktree = forgetEnterFallbacksByWorktree;
+exports.clearEnterFallbacks = clearEnterFallbacks;
+exports.beginEnterFallbackSession = beginEnterFallbackSession;
+exports.getEnterFallbackSessionEpoch = getEnterFallbackSessionEpoch;
+const prompt_key_1 = require("../../lib/detection/prompt-key");
+const auto_yes_state_1 = require("../../lib/auto-yes-state");
+const global_state_1 = require("../global-state");
+/**
+ * What tells two prompts apart for the published record: the type, the
+ * question and the option labels.
+ *
+ * Not the poller's `promptFrameKey`: that one also carries the cursor and
+ * `approvalTarget`, and the status API reads a different number of rows than
+ * the poller does, so `approvalTarget` can differ between the two readings of
+ * one screen. The record is matched against the status API's prompt (to say
+ * "Auto-Yes sent Enter" under the window it was sent to), so it is keyed on
+ * what both readings share.
+ */
+function enterFallbackScreenKey(promptData) {
+    const options = promptData.type === 'multiple_choice'
+        ? promptData.options.map((o) => `${o.number}.${o.label}`)
+        : promptData.options;
+    return [(0, prompt_key_1.generatePromptKey)(promptData), ...options].join('\u0000');
+}
+/**
+ * compositeKey -> the last Enter. `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.
+ */
+const lastEnterFallbacks = (0, global_state_1.getOrInitGlobal)('__autoYesEnterFallbacks', () => new Map());
+/**
+ * Record that Auto-Yes sent its Enter to a screen.
+ *
+ * @param at - Epoch ms; defaults to now. Overridable so tests are deterministic.
+ */
+function recordEnterFallbackSent(worktreeId, cliToolId, instanceId, sent, at = Date.now()) {
+    lastEnterFallbacks.set((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId), {
+        outcome: 'sent',
+        ...sent,
+        sentAt: at,
+        at,
+    });
+}
+/**
+ * Record that the screen the last Enter went to is still up. A no-op when there
+ * is no record, or when it is about another screen.
+ *
+ * @param at - Epoch ms; defaults to now
+ */
+function recordEnterFallbackNoEffect(worktreeId, cliToolId, instanceId, screenKey, at = Date.now()) {
+    const key = (0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId);
+    const record = lastEnterFallbacks.get(key);
+    if (!record || record.screenKey !== screenKey)
+        return;
+    lastEnterFallbacks.set(key, { ...record, outcome: 'no-effect', at });
+}
+/** @returns The last Enter for this session, or null when Auto-Yes never sent one. */
+function getLastEnterFallback(worktreeId, cliToolId, instanceId) {
+    return lastEnterFallbacks.get((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId)) ?? null;
+}
+/**
+ * The record as published, judged against the prompt the payload carries.
+ *
+ * @param promptData - The screen-read prompt of the same payload, or null
+ */
+function publishEnterFallback(record, promptData) {
+    if (record === null)
+        return null;
+    return {
+        outcome: record.outcome,
+        promptType: record.promptType,
+        refusalReason: record.refusalReason,
+        sentAt: record.sentAt,
+        at: record.at,
+        currentPrompt: promptData != null && enterFallbackScreenKey(promptData) === record.screenKey,
+    };
+}
+/**
+ * Drop one session's record (Issue #3397). Called wherever the poller for it is
+ * stopped — `stopAutoYesPolling`, which the kill-session route (through
+ * `releaseAutoYes`), the Auto-Yes disable route and an expired / disabled grant
+ * all reach. A record that outlived its session would read `currentPrompt: true`
+ * against the same question on the NEXT session, and the window would say
+ * "Auto-Yes sent Enter" about an Enter nobody sent there.
+ */
+function forgetEnterFallback(compositeKey) {
+    lastEnterFallbacks.delete(compositeKey);
+}
+/** {@link forgetEnterFallback} for every instance of a worktree. */
+function forgetEnterFallbacksByWorktree(worktreeId) {
+    for (const key of (0, auto_yes_state_1.filterCompositeKeysByWorktree)([...lastEnterFallbacks.keys()], worktreeId)) {
+        lastEnterFallbacks.delete(key);
+    }
+}
+/** Drop every record: server shutdown (`stopAllAutoYesPolling`), and a test seam. */
+function clearEnterFallbacks() {
+    lastEnterFallbacks.clear();
+}
+// =============================================================================
+// The session epoch
+// =============================================================================
+/**
+ * compositeKey -> how many sessions have been begun on it in this process.
+ * `globalThis` for the same reason as the record: `startSession` and the poller
+ * can be bundled apart under `next dev`.
+ */
+const sessionEpochs = (0, global_state_1.getOrInitGlobal)('__autoYesEnterFallbackEpochs', () => new Map());
+/**
+ * A new agent process is being created for this instance (called from
+ * `beginAgentSession`): the record is dropped, and the epoch moves on so the
+ * poller drops its own per-screen keys at its next tick.
+ */
+function beginEnterFallbackSession(worktreeId, cliToolId, instanceId) {
+    const key = (0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId);
+    lastEnterFallbacks.delete(key);
+    sessionEpochs.set(key, (sessionEpochs.get(key) ?? 0) + 1);
+}
+/** The instance's current session epoch (0 until a session is begun). */
+function getEnterFallbackSessionEpoch(compositeKey) {
+    return sessionEpochs.get(compositeKey) ?? 0;
+}

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