commandmate 0.44.1 → 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-dialog-gate.js

@@ -61,6 +61,7 @@ exports.evaluateDialogPresence = evaluateDialogPresence;
 exports.judgePromptResponse = judgePromptResponse;
 exports.assessPromptAnswerability = assessPromptAnswerability;
 const frame_1 = require("../../lib/detection/tools/frame");
+const live_region_1 = require("../../lib/detection/tools/live-region");
 const registry_1 = require("../../lib/detection/tools/registry");
 const prompt_detector_1 = require("../../lib/detection/prompt-detector");
 const cli_patterns_1 = require("../../lib/detection/cli-patterns");
@@ -203,7 +204,9 @@ const GATED_PROMPT_TYPE = 'multiple_choice';
  *   `captureAndCleanOutput` produced: ANSI **and** box drawing already removed.
  *   Every `detectDialog` implementation is written against that spelling as well
  *   as the untouched one, so the same frame reaches the same verdict on both
- *   paths.
+ *   paths. Or (Issue #3183) the `NormalizedFrame` the poller built ONCE from
+ *   the raw capture for this tick — the same object its prompt reading used, so
+ *   both read one live region; that is what the poller passes.
  * @param env - Environment to read the kill switch from; injectable for tests
  */
 function evaluateAutoYesDialogGate(cliToolId, promptType, cleanOutput, env = process.env) {
@@ -237,7 +240,9 @@ function judgeDialogPresence(cliToolId, promptType, frame, mode) {
     if (promptType !== GATED_PROMPT_TYPE || !detector.hasDialogRules || mode === 'legacy') {
         return { present: true, dialog: null, mode, gated: false };
     }
-    const dialog = detector.detectDialog((0, frame_1.normalizeFrame)(frame));
+    // Issue #3183: normalised for the tool, so the detector reads the tool's live
+    // region (and its veto) — never a whole-frame default.
+    const dialog = detector.detectDialog(typeof frame === 'string' ? (0, frame_1.normalizeFrame)(frame, cliToolId) : frame);
     return { present: dialog !== null, dialog, mode, gated: true };
 }
 /**
@@ -388,10 +393,17 @@ function assessPromptAnswerability(cliToolId, frame) {
         };
     }
     const isCommandCodeQuestion = commandCodeQuestion.kind === 'prompt';
-    const promptCheck = (commandCodeQuestion.kind === 'prompt' ? commandCodeQuestion.prompt : null)
+    const candidate = (commandCodeQuestion.kind === 'prompt' ? commandCodeQuestion.prompt : null)
         ?? toolDialog
         ?? (0, prompt_detector_1.detectPrompt)(cleanOutput, (0, cli_patterns_1.buildDetectPromptOptions)(cliToolId));
-    const presence = evaluateDialogPresence(cliToolId, promptCheck.promptData?.type, frame);
+    // Issue #3183: one frame, normalised once from the capture, for the
+    // quotation veto and the presence gate alike — the reading the status chain
+    // and the Auto-Yes poller apply, so Send is offered exactly when they agree.
+    const normalized = (0, frame_1.normalizeFrame)(frame, cliToolId);
+    const promptCheck = (0, live_region_1.isQuotedNumberedPrompt)(normalized.liveRegion, candidate)
+        ? { isPrompt: false, cleanContent: cleanOutput }
+        : candidate;
+    const presence = evaluateDialogPresence(cliToolId, promptCheck.promptData?.type, normalized);
     return {
         promptCheck,
         isCommandCodeQuestion,

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