commandmate 0.48.0 → 0.49.1

package/dist/server/src/lib/session/send-attempt-state.js

@@ -129,12 +129,30 @@ function classifySendFailure(error) {
     // literal send IS the body (`Command failed: tmux send-keys -t =s: -l -- <body>`).
     // Whether any of the body reached the pane is unknown, and the body's own words
     // (`Explain prompt not ready.`) must not be read as a readiness refusal below.
+    // #3945: the re-read under the input lock failed before any key; it quotes the
+    // capture's own error (`Command failed: tmux capture-pane …`, no body), so it
+    // is matched before the transport wordings below.
+    if (/Could not re-read session \S+ before typing \(.*\); nothing was typed \(Issue #3945\)/s.test(message)) {
+        return { state: 'not-sent', reason: 'recheck-failed' };
+    }
     if (TMUX_TRANSPORT_FAILURE.test(message))
         return { state: 'indeterminate', reason: 'send-error' };
     // The readiness waits of every tool throw before typing anything.
     if (/prompt not ready/i.test(message))
         return { state: 'not-sent', reason: 'prompt-not-ready' };
-    // #1880: refused before the body, after only the clear keys (C-e / C-u).
+    // #3945: refused under (or before getting) the instance input lock, before any key.
+    if (/input lock not acquired, nothing was typed/.test(message)) {
+        return /was replaced while this send waited/.test(message)
+            ? { state: 'not-sent', reason: 'session-replaced' }
+            : { state: 'not-sent', reason: 'input-lock-timeout' };
+    }
+    if (/\(re-checked under the input lock\); nothing was typed/.test(message)) {
+        return { state: 'not-sent', reason: 'prompt-waiting' };
+    }
+    if (/input lock lost, nothing was typed/.test(message))
+        return { state: 'not-sent', reason: 'input-lock-lost' };
+    // #1880: refused before the body, after only the clear keys (C-e / C-u, or C-e / BSpace
+    // for a codex composer holding only a paste placeholder, #3937).
     if (/still holds unsent text after \d+ clear passes/.test(message)) {
         return { state: 'not-sent', reason: 'composer-not-empty' };
     }

package/dist/server/src/lib/session/send-attempt-types.js

@@ -9,9 +9,17 @@
  * @module lib/session/send-attempt-types
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PLAN_REVIEW_SEND_REFUSED_CODE = void 0;
+exports.INPUT_RECHECK_FAILED_CODE = exports.INPUT_RECHECK_PROMPT_WAITING_CODE = exports.PLAN_REVIEW_SEND_REFUSED_CODE = void 0;
 /**
  * `code` on the error a tool throws when a plan review overlay refuses the
  * send before any body is typed (Issue #3772). Matched by code, never by wording.
  */
 exports.PLAN_REVIEW_SEND_REFUSED_CODE = 'PLAN_REVIEW_SEND_REFUSED';
+/**
+ * `code` on the errors the input re-check throws before any key
+ * (`recheckComposerBeforeInput`, Issue #3952): a dialog was open, or the pane
+ * could not be read. Carried by copilot's `/model` switch, whose caller records
+ * the reason by code rather than by the wording around it.
+ */
+exports.INPUT_RECHECK_PROMPT_WAITING_CODE = 'INPUT_RECHECK_PROMPT_WAITING';
+exports.INPUT_RECHECK_FAILED_CODE = 'INPUT_RECHECK_FAILED';

package/dist/server/src/lib/session/send-user-message.js

@@ -31,7 +31,15 @@
  *
  * Every attempt that reaches the ownership check also records how it ended —
  * not-sent / sent / indeterminate — for `prompt --json`'s `lastSend` (Issue
- * #3759, `./send-attempt-state`). Nothing is resent on any outcome.
+ * #3759, `./send-attempt-state`). Nothing is resent on any outcome. The
+ * caller can also be handed its own attempt (`onAttempt`, Issue #3945), so it
+ * describes this send rather than whichever send to the instance recorded last.
+ *
+ * Issue #3945: for the tools whose composer is read after a failure (claude,
+ * codex), step 4 runs under the instance's input lock, the failure read
+ * included — a read made after the lock was released could be reading the next
+ * send's body. The tool's own sender joins that lock rather than queueing
+ * behind it (`instance-input-lock`).
  *
  * Out of scope (kept in the HTTP layer / caller): request/body validation,
  * content trimming/size limits, imagePath validation, CLI-tool availability
@@ -54,8 +62,10 @@ const prompt_waiting_guard_1 = require("../../lib/session/prompt-waiting-guard")
 const session_start_error_1 = require("../../lib/session/session-start-error");
 const cli_session_1 = require("../../lib/session/cli-session");
 const send_attempt_state_1 = require("../../lib/session/send-attempt-state");
+const send_attempt_types_1 = require("../../lib/session/send-attempt-types");
 const composer_text_1 = require("../../lib/detection/composer-text");
 const status_capture_config_1 = require("../../config/status-capture-config");
+const instance_input_lock_1 = require("../../lib/session/instance-input-lock");
 const opencode_1 = require("../../lib/cli-tools/opencode");
 const logger = (0, logger_1.createLogger)('session/send-user-message');
 function getErrorMessage(error) {
@@ -146,6 +156,7 @@ async function sendUserMessage(db, params) {
     // unchanged; recording never throws.
     const settle = (state, reason) => {
         (0, send_attempt_state_1.recordSendAttempt)({ worktreeId, cliToolId, instanceId: resolvedInstanceId }, { state, reason, content });
+        params.onAttempt?.({ state, reason });
     };
     // Issue #2865: the send route checks ownership itself, but the timer manager
     // and relay delivery reach tmux only through here. A session under this
@@ -232,7 +243,14 @@ async function sendUserMessage(db, params) {
         }
         catch (error) {
             logger.error('failed-to-send-model-command:', { error: getErrorMessage(error) });
-            settle('not-sent', 'model-switch-failed');
+            // Issue #3952: the re-check right before `/model` refused it. Read by
+            // code, not wording: the switch's other errors quote the pane's bottom row.
+            const code = error?.code;
+            if (code === send_attempt_types_1.INPUT_RECHECK_PROMPT_WAITING_CODE) {
+                settle('not-sent', 'prompt-waiting');
+                return { ok: false, stage: 'prompt_waiting', error: (0, prompt_waiting_guard_1.promptWaitingMessage)(worktreeId) };
+            }
+            settle('not-sent', code === send_attempt_types_1.INPUT_RECHECK_FAILED_CODE ? 'recheck-failed' : 'model-switch-failed');
             return { ok: false, stage: 'model', error: getErrorMessage(error) };
         }
         // Issue #2630: copilot is idle now, and if the previous turn ended during the
@@ -269,10 +287,16 @@ async function sendUserMessage(db, params) {
     // behind a dialog (refused by the prompt guard above), and returns at once
     // while a turn is running. A send without `--model` skips step 1, so its stamp
     // is read at the same point as before.
-    const userMessageTimestamp = new Date();
+    //
+    // Issue #3953: this is now the pending row's stamp, and the user row's only
+    // when the sender did not report when input started (see step 4). The waits
+    // between here and the first key — the input lock, a carried paste mark, the
+    // re-read and the clear — can last a minute, and a previous turn that ended
+    // inside them is not this send's.
+    const pendingResponseTimestamp = new Date();
     // 2. Save any pending assistant response before sending the new user message.
     try {
-        await (0, assistant_response_saver_1.savePendingAssistantResponse)(db, worktreeId, cliToolId, userMessageTimestamp, instanceId);
+        await (0, assistant_response_saver_1.savePendingAssistantResponse)(db, worktreeId, cliToolId, pendingResponseTimestamp, instanceId);
     }
     catch (error) {
         // Log but don't fail - user message should still be saved
@@ -318,8 +342,31 @@ async function sendUserMessage(db, params) {
         // Log but don't fail - cleanup candidate discovery is best-effort
         logger.error('failed-to-detect-orphaned-messages:', { error: getErrorMessage(error) });
     }
-    // 4. Send message to CLI tool.
-    try {
+    // 4. Send message to CLI tool (run below). Returns the failure, or when sent
+    // the moment the sender started typing the body (Issue #3953; null for a
+    // path that does not report it).
+    async function deliver() {
+        try {
+            const { inputStartedAt } = await (0, instance_input_lock_1.observeInputStart)(sendToTool, params.onInputStart, params.inputBoundary);
+            return { sent: true, inputStartedAt };
+        }
+        catch (error) {
+            logger.error('failed-to-send-message-to:', { error: getErrorMessage(error) });
+            // Issue #3957: the relay's boundary hook refused before the first key —
+            // nothing was typed because the reservation the body was going in under
+            // was gone. Issue #3992: its own reason, not `input-lock-lost`.
+            if ((0, instance_input_lock_1.isInputBoundaryRefusal)(error)) {
+                return { error, failure: { state: 'not-sent', reason: 'relay-reservation-lost' } };
+            }
+            // Issue #3759: not-sent only when the error says the body was never typed.
+            let failure = (0, send_attempt_state_1.classifySendFailure)(error);
+            if (failure.reason === 'submit-unconfirmed' && (await composerStillHolds(worktreeId, cliToolId, instanceId, content))) {
+                failure = { state: 'indeterminate', reason: 'composer-residue' };
+            }
+            return { error, failure };
+        }
+    }
+    async function sendToTool() {
         // Issue #474: Image-aware sending
         if (absoluteImagePath) {
             if ((0, types_1.isImageCapableCLITool)(cliTool)) {
@@ -351,20 +398,42 @@ async function sendUserMessage(db, params) {
             await cliTool.sendMessage(worktreeId, content, instanceId);
         }
     }
-    catch (error) {
-        logger.error('failed-to-send-message-to:', { error: getErrorMessage(error) });
-        // Issue #3759: not-sent only when the error says the body was never typed.
-        let failure = (0, send_attempt_state_1.classifySendFailure)(error);
-        if (failure.reason === 'submit-unconfirmed' && (await composerStillHolds(worktreeId, cliToolId, instanceId, content))) {
-            failure = { state: 'indeterminate', reason: 'composer-residue' };
-        }
+    // Issue #3945: under the input lock for the tools whose composer is read
+    // after a failure, so that read is of this send's composer. Not for the
+    // others — opencode's HTTP delivery never touches the composer, and holding
+    // the lock across it would stall a concurrent tmux send for nothing; their
+    // tmux path takes the lock inside the shared sender.
+    const delivery = composer_text_1.SUPPORTED_COMPOSER_TOOLS.has(cliToolId)
+        ? await (0, instance_input_lock_1.withInstanceInputLock)(sessionName, () => deliver()).catch((error) => ({
+            error,
+            failure: (0, send_attempt_state_1.classifySendFailure)(error),
+        }))
+        : await deliver();
+    if (!('sent' in delivery)) {
+        const { error, failure } = delivery;
         settle(failure.state, failure.reason);
+        // Issue #3945: a dialog found by the re-check under the lock is the prompt
+        // guard's refusal, found late — answered as that refusal (relay holds it).
+        if (failure.reason === 'prompt-waiting') {
+            return { ok: false, stage: 'prompt_waiting', error: (0, prompt_waiting_guard_1.promptWaitingMessage)(worktreeId) };
+        }
         if ((0, session_start_error_1.isSessionStartTimeoutError)(error)) {
             return { ok: false, stage: 'send', error: error.message, code: session_start_error_1.SESSION_STARTING_CODE };
         }
         return { ok: false, stage: 'send', error: getErrorMessage(error) };
     }
     settle('sent', 'submitted');
+    // Issue #3953: the user row, `updateLastUserMessage` and so `wait`'s #1975
+    // gate take the moment the body started going in — later than any turn that
+    // ended before it, earlier than the `stop` of the turn it starts (a stamp
+    // taken after the send could be later than a turn that ends at once). Never
+    // earlier than the pending row's stamp, which stays before it by
+    // ASSISTANT_TIMESTAMP_OFFSET_MS. A path that does not report input (opencode's
+    // HTTP delivery) keeps the stamp read before step 2, as before.
+    const inputStartedAt = delivery.inputStartedAt;
+    const userMessageTimestamp = inputStartedAt !== null && inputStartedAt.getTime() > pendingResponseTimestamp.getTime()
+        ? inputStartedAt
+        : pendingResponseTimestamp;
     // 5. Create user message in database (History source: chat_messages).
     const message = (0, db_1.createMessage)(db, {
         worktreeId,

package/dist/server/src/lib/session/waiting-episode-state-ops.js

@@ -0,0 +1,152 @@
+"use strict";
+/**
+ * The low-level episode writes: open / close / replace / rebind / updateKind
+ * (Issue #3798). Each one emits through the store's listeners.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openEpisode = openEpisode;
+exports.closeEpisode = closeEpisode;
+exports.replaceEpisode = replaceEpisode;
+exports.rebindEpisode = rebindEpisode;
+exports.updateEpisodeKind = updateEpisodeKind;
+const waiting_episode_state_store_1 = require("../../lib/session/waiting-episode-state-store");
+/**
+ * Open an episode (Issue #3798). Low-level: the caller has decided there is
+ * none open and what it is bound to. Emits the opening edge.
+ */
+function openEpisode(parts, next, at) {
+    const key = (0, waiting_episode_state_store_1.keyOf)(parts);
+    const view = { since: next.since, kind: next.kind };
+    const meta = {
+        episodeId: (0, waiting_episode_state_store_1.nextEpisodeId)(),
+        openedAt: at,
+        boundAt: at,
+        binding: next.binding,
+        openedBy: next.openedBy,
+        promptScreenKey: next.promptScreenKey ?? null,
+    };
+    waiting_episode_state_store_1.episodes.set(key, view);
+    waiting_episode_state_store_1.metas.set(view, meta);
+    (0, waiting_episode_state_store_1.bumpVersion)(key);
+    (0, waiting_episode_state_store_1.emit)({
+        worktreeId: parts.worktreeId,
+        cliToolId: parts.cliToolId,
+        instanceId: parts.instanceId,
+        waiting: true,
+        since: view.since,
+        kind: view.kind,
+        at,
+        cause: 'opened',
+        episodeId: meta.episodeId,
+        previousEpisodeId: null,
+        closeReason: null,
+    });
+    return { ...view, ...meta };
+}
+/**
+ * Close the open episode when it is still `expectedId` (Issue #3798). A closer
+ * that names the episode it decided about cannot close a later one.
+ *
+ * @returns Whether an episode was closed
+ */
+function closeEpisode(parts, expectedId, reason, at) {
+    const key = (0, waiting_episode_state_store_1.keyOf)(parts);
+    const view = waiting_episode_state_store_1.episodes.get(key);
+    if (view === undefined)
+        return false;
+    const meta = (0, waiting_episode_state_store_1.metaOf)(view);
+    if (meta.episodeId !== expectedId)
+        return false;
+    waiting_episode_state_store_1.episodes.delete(key);
+    waiting_episode_state_store_1.lastClosed.set(key, { at, promptScreenKey: meta.promptScreenKey });
+    (0, waiting_episode_state_store_1.bumpVersion)(key);
+    (0, waiting_episode_state_store_1.emit)({
+        worktreeId: parts.worktreeId,
+        cliToolId: parts.cliToolId,
+        instanceId: parts.instanceId,
+        waiting: false,
+        since: null,
+        kind: null,
+        at,
+        cause: 'closed',
+        episodeId: null,
+        previousEpisodeId: meta.episodeId,
+        closeReason: reason,
+    });
+    return true;
+}
+/**
+ * Put a new episode in place of `expectedId` as one operation (Issue #3798):
+ * listeners hear a single opening edge for the new wait and no closing one
+ * in between, so nothing reports "nobody is waiting" mid-swap.
+ *
+ * @returns The new episode, or null when `expectedId` is no longer open
+ */
+function replaceEpisode(parts, expectedId, next, reason, at) {
+    const key = (0, waiting_episode_state_store_1.keyOf)(parts);
+    const old = waiting_episode_state_store_1.episodes.get(key);
+    if (old === undefined)
+        return null;
+    const oldMeta = (0, waiting_episode_state_store_1.metaOf)(old);
+    if (oldMeta.episodeId !== expectedId)
+        return null;
+    waiting_episode_state_store_1.lastClosed.set(key, { at, promptScreenKey: oldMeta.promptScreenKey });
+    const view = { since: next.since, kind: next.kind };
+    const meta = {
+        episodeId: (0, waiting_episode_state_store_1.nextEpisodeId)(),
+        openedAt: at,
+        boundAt: at,
+        binding: next.binding,
+        openedBy: next.openedBy,
+        promptScreenKey: next.promptScreenKey ?? null,
+    };
+    waiting_episode_state_store_1.episodes.set(key, view);
+    waiting_episode_state_store_1.metas.set(view, meta);
+    (0, waiting_episode_state_store_1.bumpVersion)(key);
+    (0, waiting_episode_state_store_1.emit)({
+        worktreeId: parts.worktreeId,
+        cliToolId: parts.cliToolId,
+        instanceId: parts.instanceId,
+        waiting: true,
+        since: view.since,
+        kind: view.kind,
+        at,
+        cause: 'replaced',
+        episodeId: meta.episodeId,
+        previousEpisodeId: oldMeta.episodeId,
+        closeReason: reason,
+    });
+    return { ...view, ...meta };
+}
+/**
+ * Change what the open episode `expectedId` is bound to (Issue #3798). Not an
+ * edge: the wait goes on, so nothing is emitted and `since` stays.
+ *
+ * @returns Whether the episode was rebound
+ */
+function rebindEpisode(parts, expectedId, binding, at) {
+    const key = (0, waiting_episode_state_store_1.keyOf)(parts);
+    const view = waiting_episode_state_store_1.episodes.get(key);
+    if (view === undefined)
+        return false;
+    const meta = (0, waiting_episode_state_store_1.metaOf)(view);
+    if (meta.episodeId !== expectedId)
+        return false;
+    meta.binding = binding;
+    meta.boundAt = at;
+    (0, waiting_episode_state_store_1.bumpVersion)(key);
+    return true;
+}
+/**
+ * Refresh the kind of the open episode `expectedId` (Issue #3798, I10). The
+ * wait goes on: no edge, and the version does not move.
+ *
+ * @returns Whether the episode was still open
+ */
+function updateEpisodeKind(parts, expectedId, kind) {
+    const view = waiting_episode_state_store_1.episodes.get((0, waiting_episode_state_store_1.keyOf)(parts));
+    if (view === undefined || (0, waiting_episode_state_store_1.metaOf)(view).episodeId !== expectedId)
+        return false;
+    view.kind = kind;
+    return true;
+}

package/dist/server/src/lib/session/waiting-episode-state-store.js

@@ -0,0 +1,202 @@
+"use strict";
+/**
+ * The waiting-episode store's state tables, its listeners and the reads
+ * (Issue #1786 / #3798). The single place that initialises each `globalThis` slot.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UNKNOWN_BINDING = exports.lastClosed = exports.metas = exports.episodes = void 0;
+exports.nextEpisodeId = nextEpisodeId;
+exports.keyOf = keyOf;
+exports.bumpVersion = bumpVersion;
+exports.onWaitingTransition = onWaitingTransition;
+exports.onWaitingEpisodeTransition = onWaitingEpisodeTransition;
+exports.emit = emit;
+exports.metaOf = metaOf;
+exports.getWaitingEpisodeRecord = getWaitingEpisodeRecord;
+exports.getEpisodeVersion = getEpisodeVersion;
+exports.snapshotEpisodeVersions = snapshotEpisodeVersions;
+exports.getLastClosedEpisode = getLastClosedEpisode;
+exports.getWaitingEpisode = getWaitingEpisode;
+exports.hasOpenWaitingEpisode = hasOpenWaitingEpisode;
+exports.clearWaitingEpisodes = clearWaitingEpisodes;
+exports.clearWaitingTransitionListeners = clearWaitingTransitionListeners;
+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)('waiting-episode-state');
+/** compositeKey -> the wait currently in progress for that instance. */
+exports.episodes = (0, global_state_1.getOrInitGlobal)('__sessionWaitingEpisodes', () => new Map());
+/** Subscribers to the edge. See the module docblock. */
+const listeners = (0, global_state_1.getOrInitGlobal)('__sessionWaitingTransitionListeners', () => new Set());
+exports.metas = (0, global_state_1.getOrInitGlobal)('__sessionWaitingEpisodeMeta', () => new WeakMap());
+const versions = (0, global_state_1.getOrInitGlobal)('__sessionWaitingEpisodeVersions', () => new Map());
+exports.lastClosed = (0, global_state_1.getOrInitGlobal)('__sessionWaitingEpisodeLastClosed', () => new Map());
+const episodeSeq = (0, global_state_1.getOrInitGlobal)('__sessionWaitingEpisodeSeq', () => ({
+    value: 0,
+    nonce: Math.random().toString(36).slice(2, 10),
+}));
+const episodeListeners = (0, global_state_1.getOrInitGlobal)('__sessionWaitingEpisodeListeners', () => new Set());
+/** The binding used when no resolver is registered: nothing is known. */
+exports.UNKNOWN_BINDING = {
+    kind: 'unattributed',
+    generation: { kind: 'none' },
+    lastClosedTurnId: null,
+};
+function nextEpisodeId() {
+    episodeSeq.value += 1;
+    return `wep-${episodeSeq.nonce}-${episodeSeq.value}`;
+}
+function keyOf(parts) {
+    return (0, auto_yes_state_1.buildCompositeKey)(parts.worktreeId, parts.cliToolId, parts.instanceId);
+}
+function bumpVersion(key) {
+    versions.set(key, (versions.get(key) ?? 0) + 1);
+}
+/**
+ * Subscribe to waiting edges.
+ *
+ * @returns An unsubscribe function. Idempotent — calling it twice is harmless.
+ */
+function onWaitingTransition(listener) {
+    listeners.add(listener);
+    return () => {
+        listeners.delete(listener);
+    };
+}
+/**
+ * Subscribe to waiting edges with the episode's identity (Issue #3798).
+ *
+ * The same crossings `onWaitingTransition` delivers, in the same order, with
+ * the cause, the episode ids and the close reason added.
+ */
+function onWaitingEpisodeTransition(listener) {
+    episodeListeners.add(listener);
+    return () => {
+        episodeListeners.delete(listener);
+    };
+}
+/** Notify subscribers, containing anything they throw. */
+function emit(transition) {
+    const { cause: _cause, episodeId: _id, previousEpisodeId: _prev, closeReason: _reason, ...plain } = transition;
+    for (const listener of listeners) {
+        try {
+            listener(plain);
+        }
+        catch (error) {
+            logListenerFailure(transition, error);
+        }
+    }
+    for (const listener of episodeListeners) {
+        try {
+            listener(transition);
+        }
+        catch (error) {
+            logListenerFailure(transition, error);
+        }
+    }
+}
+function logListenerFailure(transition, error) {
+    logger.error('waiting-transition-listener-failed', {
+        worktreeId: transition.worktreeId,
+        cliToolId: transition.cliToolId,
+        instanceId: transition.instanceId ?? transition.cliToolId,
+        waiting: transition.waiting,
+        error: error instanceof Error ? error.message : String(error),
+    });
+}
+/**
+ * The meta of an episode in the map. An episode put there without one (a test
+ * that wrote the map directly) is given an unattributed identity on first read.
+ */
+function metaOf(view) {
+    let meta = exports.metas.get(view);
+    if (meta === undefined) {
+        meta = {
+            episodeId: nextEpisodeId(),
+            openedAt: view.since,
+            boundAt: view.since,
+            binding: exports.UNKNOWN_BINDING,
+            openedBy: 'legacy-edge',
+            promptScreenKey: null,
+        };
+        exports.metas.set(view, meta);
+    }
+    return meta;
+}
+/** The open episode with its identity and binding, or null (Issue #3798). */
+function getWaitingEpisodeRecord(worktreeId, cliToolId, instanceId) {
+    const view = exports.episodes.get((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId));
+    if (view === undefined)
+        return null;
+    const meta = metaOf(view);
+    return { since: view.since, kind: view.kind, ...meta, binding: meta.binding };
+}
+/** The instance's episode version: it moves on every open, close, replacement and rebind. */
+function getEpisodeVersion(worktreeId, cliToolId, instanceId) {
+    return versions.get((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId)) ?? 0;
+}
+/**
+ * Every instance version of one worktree, as of now (Issue #3798): the status
+ * probe fixes them before it lists the tmux sessions. An instance missing from
+ * the map is at version 0.
+ */
+function snapshotEpisodeVersions(worktreeId) {
+    const prefix = `${worktreeId}${auto_yes_state_1.COMPOSITE_KEY_SEPARATOR}`;
+    const snapshot = new Map();
+    for (const [key, version] of versions) {
+        if (key.startsWith(prefix))
+            snapshot.set(key, version);
+    }
+    return snapshot;
+}
+/** The last episode that ended for this instance, or null. */
+function getLastClosedEpisode(worktreeId, cliToolId, instanceId) {
+    return exports.lastClosed.get((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId)) ?? null;
+}
+/**
+ * @returns The wait in progress for this instance, or null when it is not
+ *   waiting. Read-only: observing the edge is {@link observeWaitingEdge}'s job.
+ */
+function getWaitingEpisode(worktreeId, cliToolId, instanceId) {
+    return exports.episodes.get((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId)) ?? null;
+}
+/**
+ * Whether **any** instance in this worktree is still waiting (Issue #2001).
+ *
+ * The cross-device dismissal is keyed on the worktree, because that is what the
+ * Service Worker `tag` names (`<worktreeId>:prompt`, `push-sender`): two agent
+ * instances waiting in one worktree share a single notification card on the
+ * phone. So one instance crossing the closing edge is not on its own a reason
+ * to clear that card — the card is still telling the truth until the last of
+ * them has been answered.
+ *
+ * The prefix test is exact rather than heuristic: `buildCompositeKey` puts the
+ * worktree id first and rejects a worktree id containing
+ * {@link COMPOSITE_KEY_SEPARATOR}, so no other worktree's key can start with
+ * `<worktreeId>:`.
+ */
+function hasOpenWaitingEpisode(worktreeId) {
+    const prefix = `${worktreeId}${auto_yes_state_1.COMPOSITE_KEY_SEPARATOR}`;
+    for (const key of exports.episodes.keys()) {
+        if (key.startsWith(prefix))
+            return true;
+    }
+    return false;
+}
+/**
+ * Drop every episode. Test seam.
+ *
+ * CI runs with `fileParallelism: false`, so one process holds this map for the
+ * whole suite: a test that opens an episode and does not clear it hands the next
+ * file a session that is already waiting.
+ */
+function clearWaitingEpisodes() {
+    exports.episodes.clear();
+    versions.clear();
+    exports.lastClosed.clear();
+}
+/** Drop every subscriber. Test seam, paired with {@link clearWaitingEpisodes}. */
+function clearWaitingTransitionListeners() {
+    listeners.clear();
+    episodeListeners.clear();
+}

package/dist/server/src/lib/session/waiting-episode-state-types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * The types of the waiting-episode store (Issue #1786 / #3798). No runtime
+ * state lives here; `waiting-episode-state` re-exports every public name.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });