commandmate 0.44.2 → 0.45.0

package/dist/server/src/lib/hooks/sources/opencode-v2/mappers.js

@@ -125,10 +125,11 @@ function frameDecisionId(payload) {
  * The decision id ({@link frameDecisionId}) — the `per_…` / `frm_…` the reply
  * URL takes. An approval and the reply that settles it carry the SAME id, which
  * is why `classifyAgentEventDelivery` keys on `(event, detail, identity)`
- * rather than on the id alone. Every other frame (the `session.execution.*`
- * boundaries) answers null and keeps the time window, as v1's `session.idle`
- * does. The envelope's `evt_…` is not used, for v1's reason: nothing measured
- * says it is unique per frame.
+ * rather than on the id alone. Every other frame answers null. Of those only
+ * `session.execution.started` meets the time window (the `succeeded` /
+ * `failed` / `interrupted` boundaries are `stop`s, which it never suppresses —
+ * see `classifyAgentEventDelivery`). The envelope's `evt_…` is not used, for
+ * v1's reason: nothing measured says it is unique per frame.
  */
 function opencodeV2EventIdentity(payload) {
     return (0, event_mapper_1.readEventIdentity)(frameDecisionId(payload));

package/dist/server/src/lib/hooks/sources/opencode-v2/ports.js

@@ -38,13 +38,14 @@ const path_1 = require("path");
 const logger_1 = require("../../../../lib/logger");
 const ports_1 = require("../opencode/ports");
 const secrets_1 = require("./secrets");
+const global_state_1 = require("../../../global-state");
 const logger = (0, logger_1.createLogger)('lib/hooks/sources/opencode-v2/ports');
 /** Ports OpenCode V2 servers are started on. Disjoint from v1's 4200–4299. */
 exports.OPENCODE_V2_PORT_RANGE = { min: 4300, max: 4399 };
 const PORT_SPAN = exports.OPENCODE_V2_PORT_RANGE.max - exports.OPENCODE_V2_PORT_RANGE.min + 1;
 /** File name of the persisted assignments inside the state directory. */
 exports.OPENCODE_V2_PORT_FILE_NAME = 'ports.json';
-const assignments = (globalThis.__opencodeV2PortAssignments ??= new Map());
+const assignments = (0, global_state_1.getOrInitGlobal)('__opencodeV2PortAssignments', () => new Map());
 /** Absolute path of the persisted assignments. */
 function getOpencodeV2PortFilePath() {
     return (0, path_1.join)((0, secrets_1.getOpencodeV2StateDir)(), exports.OPENCODE_V2_PORT_FILE_NAME);

package/dist/server/src/lib/hooks/sources/opencode-v2/subscription.js

@@ -37,7 +37,6 @@ exports.OPENCODE_V2_MAX_RESYNCED_DECISIONS = exports.OPENCODE_V2_MAX_REJECTED_PR
 exports.isOpencodeV2Subscribed = isOpencodeV2Subscribed;
 exports.getOpencodeV2Liveness = getOpencodeV2Liveness;
 exports.isOpencodeV2StructuredHistoryLive = isOpencodeV2StructuredHistoryLive;
-exports.getOpencodeV2SubscribedPort = getOpencodeV2SubscribedPort;
 exports.openOpencodeV2Subscription = openOpencodeV2Subscription;
 exports.closeOpencodeV2Subscription = closeOpencodeV2Subscription;
 exports.resetOpencodeV2Subscriptions = resetOpencodeV2Subscriptions;
@@ -45,6 +44,7 @@ exports.resyncOpencodeV2Pending = resyncOpencodeV2Pending;
 exports.deliverOpencodeV2Frame = deliverOpencodeV2Frame;
 exports.refreshOpencodeV2UsageOnFrame = refreshOpencodeV2UsageOnFrame;
 exports.recordOpencodeV2TurnEnd = recordOpencodeV2TurnEnd;
+const global_state_1 = require("../../../../lib/global-state");
 const agent_session_telemetry_1 = require("../../../../lib/hooks/agent-session-telemetry");
 const logger_1 = require("../../../../lib/logger");
 const event_mapper_1 = require("../event-mapper");
@@ -72,9 +72,9 @@ exports.OPENCODE_V2_MAX_REJECTED_PROBES = 3;
  * off a server CommandMate does not police.
  */
 exports.OPENCODE_V2_MAX_RESYNCED_DECISIONS = 50;
-const subscriptions = (globalThis.__opencodeV2Subscriptions ??= new Map());
+const subscriptions = (0, global_state_1.getOrInitGlobal)('__opencodeV2Subscriptions', () => new Map());
 /** The last liveness of a subscription that ended on its own, for `liveness()`. */
-const endedLiveness = (globalThis.__opencodeV2EndedLiveness ??= new Map());
+const endedLiveness = (0, global_state_1.getOrInitGlobal)('__opencodeV2EndedLiveness', () => new Map());
 /** Whether a subscription is open for the instance. */
 function isOpencodeV2Subscribed(target) {
     return subscriptions.has((0, secrets_1.opencodeV2KeyOf)(target));
@@ -97,10 +97,6 @@ function getOpencodeV2Liveness(target) {
 function isOpencodeV2StructuredHistoryLive(target) {
     return getOpencodeV2Liveness(target).state === 'live';
 }
-/** The port an open subscription reads, or null. */
-function getOpencodeV2SubscribedPort(target) {
-    return subscriptions.get((0, secrets_1.opencodeV2KeyOf)(target))?.port ?? null;
-}
 function handleFor(state) {
     return {
         close: async () => {

package/dist/server/src/lib/hooks/sources/opencode-v2/usage.js

@@ -58,6 +58,7 @@ const event_mapper_1 = require("../event-mapper");
 const client_1 = require("./client");
 const history_1 = require("./history");
 const secrets_1 = require("./secrets");
+const global_state_1 = require("../../../global-state");
 const logger = (0, logger_1.createLogger)('lib/hooks/sources/opencode-v2/usage');
 /** The frame that says a session's running total moved. */
 exports.OPENCODE_V2_USAGE_EVENT_TYPE = 'session.usage.updated';
@@ -179,7 +180,7 @@ async function refreshOpencodeV2SessionUsage(target, port, sessionId, isCurrent
     }
 }
 /** One refresh in flight per instance, on `globalThis` for #1736's reason. */
-const slots = (globalThis.__opencodeV2UsageRefreshes ??= new Map());
+const slots = (0, global_state_1.getOrInitGlobal)('__opencodeV2UsageRefreshes', () => new Map());
 /** Forget in-flight markers. Test seam. */
 function resetOpencodeV2UsageRefreshes() {
     slots.clear();

package/dist/server/src/lib/hooks/sources/pending-decisions.js

@@ -36,8 +36,9 @@ exports.answerPendingDecision = answerPendingDecision;
 exports.answerPendingDecisionWithReceipt = answerPendingDecisionWithReceipt;
 const auto_yes_state_1 = require("../../../lib/auto-yes-state");
 const logger_1 = require("../../../lib/logger");
+const global_state_1 = require("../../global-state");
 const logger = (0, logger_1.createLogger)('lib/hooks/sources/pending-decisions');
-const pendingByInstance = (globalThis.__agentSourcePendingDecisions ??= new Map());
+const pendingByInstance = (0, global_state_1.getOrInitGlobal)('__agentSourcePendingDecisions', () => new Map());
 /**
  * Cap on simultaneously open slots for one instance.
  *

package/dist/server/src/lib/hooks/sources/registry.js

@@ -42,9 +42,10 @@ const source_5 = require("./codex/source");
 const source_6 = require("./opencode/source");
 const source_7 = require("./command-code/source");
 const source_8 = require("./opencode-v2/source");
-const registered = (globalThis.__agentEventSources ??= new Map());
+const global_state_1 = require("../../global-state");
+const registered = (0, global_state_1.getOrInitGlobal)('__agentEventSources', () => new Map());
 /** Memoised compatibility sources, so repeated lookups return one object. */
-const legacy = (globalThis.__agentEventLegacySources ??= new Map());
+const legacy = (0, global_state_1.getOrInitGlobal)('__agentEventLegacySources', () => new Map());
 /**
  * Add or replace a tool's source.
  *

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