commandmate 0.49.3 → 0.50.0

package/dist/server/src/lib/session/claude-session.js

@@ -25,6 +25,7 @@ const child_process_1 = require("child_process");
 const util_1 = require("util");
 const promises_1 = require("fs/promises");
 const logger_1 = require("../../lib/logger");
+const claude_auto_default_nudge_1 = require("../../lib/cli-tools/claude-auto-default-nudge");
 const session_ownership_1 = require("../../lib/cli-tools/session-ownership");
 const session_name_1 = require("../../lib/cli-tools/session-name");
 const sources_1 = require("../../lib/hooks/sources");
@@ -35,6 +36,7 @@ const agent_event_state_1 = require("../../lib/session/agent-event-state");
 const session_start_error_1 = require("../../lib/session/session-start-error");
 const launch_screen_1 = require("../../lib/session/launch-screen");
 const instance_input_lock_1 = require("../../lib/session/instance-input-lock");
+const launch_answer_skips_1 = require("../../lib/cli-tools/launch-answer-skips");
 const session_launch_flight_1 = require("../../lib/session/session-launch-flight");
 const launch_keys_1 = require("../../lib/cli-tools/launch-keys");
 const logger = (0, logger_1.createLogger)('claude-session');
@@ -156,6 +158,69 @@ const TRUST_DIALOG_MAX_MOVES = 20;
 exports.CLAUDE_TRUST_DIALOG_CURSOR_STUCK = 'trust dialog: cursor did not reach "Yes, I trust this folder"';
 /** Reported when Claude Code quit from the trust dialog (Issue #3089). A fixed string, never captured output. */
 exports.CLAUDE_TRUST_DIALOG_EXITED = 'trust dialog: Claude Code exited to the shell';
+/** The log event of a trust-dialog key that did not go out (Issue #4149). */
+const TRUST_KEY_SKIPPED = 'trust-dialog-key-skipped';
+/**
+ * The start budget ran out with a startup dialog on the screen (Issue #4149).
+ *
+ * Nothing about that is slow, so {@link SessionStartTimeoutError}'s sentence would send
+ * the reader off to wait. Still that error to everything that reads it (`code`): the
+ * session is left alive, nothing was typed, the answer is a 503 and no push is sent. The
+ * message follows the module's rule (SEC-SF-002): built only from fixed strings, the
+ * session name, a number and {@link TrustDialogKeySkip}, never captured output.
+ */
+class ClaudeStartupDialogStalledError extends session_start_error_1.SessionStartTimeoutError {
+    /**
+     * @param where - Says what the session is stopped on, and what became of the keys
+     * @param next - What the reader can do: a send to a running process answers only some dialogs
+     */
+    constructor(sessionName, timeoutMs, where, next) {
+        super('Claude Code', sessionName, timeoutMs);
+        this.message =
+            `Claude Code did not reach its input prompt within ${Math.round(timeoutMs / 1000)}s (initialization timeout): ` +
+                `the tmux session '${sessionName}' is stopped on ${where} This is not a slow start, so waiting will not ` +
+                `move it. The message was not delivered. ${next}`;
+        this.name = 'ClaudeStartupDialogStalledError';
+    }
+}
+/**
+ * The error for a start whose budget ran out, by what its last screen shows.
+ *
+ * @param lastScreen - The last pane output read, or null when none could be
+ */
+function startTimeoutError(sessionName, lastScreen, trust) {
+    if (lastScreen !== null && (0, cli_patterns_1.isClaudeTrustDialogOpen)(lastScreen)) {
+        const keys = trust.answers + trust.moves;
+        const fate = keys === 0
+            ? `no key reached it (${trust.lastSkip ?? 'no key was due'})`
+            : `it stayed open after ${keys} keys`;
+        return new ClaudeStartupDialogStalledError(sessionName, exports.CLAUDE_INIT_TIMEOUT, `the folder-trust dialog, and ${fate}. Enter is never pressed while the cursor is on "No, exit".`, 
+        // The process stays, and a send to a running one reuses it without answering this dialog.
+        'A send on its own does not answer this dialog: run `commandmate capture <worktree-id>` to see it, ' +
+            'clear it in a terminal with `commandmate attach <worktree-id>` (each with --instance for a named instance), ' +
+            'then send the message again. A retry before that will not get through.');
+    }
+    if (lastScreen !== null && (0, cli_patterns_1.isClaudeAutoDefaultNudgeOpen)(lastScreen)) {
+        return new ClaudeStartupDialogStalledError(sessionName, exports.CLAUDE_INIT_TIMEOUT, '"Make auto mode your default permission mode?", which did not take its keys. No keeps the current mode.', 
+        // A send answers this one first (answerClaudeAutoDefaultNudgeBeforeSend).
+        'Send it again, or run `commandmate capture <worktree-id>` to see the dialog.');
+    }
+    return new session_start_error_1.SessionStartTimeoutError('Claude Code', sessionName, exports.CLAUDE_INIT_TIMEOUT);
+}
+/**
+ * Record a key that did not go out, at warn (Issue #4149: at info an ERROR-only setting
+ * hid the only trace of a start that sent nothing). Once per reason in a row: a key that
+ * cannot go out is due again on every poll.
+ *
+ * Issue #4211: the record is the wait's {@link LaunchAnswerSkips} (#4189), which is
+ * also the lock's `repeatScope`: a key that went out ends the streak, and a session
+ * made again (`invalidateInstanceInput`) is a new one. `startedIn` is the life taken
+ * before the key's await, as the nudge and the other tools take it.
+ */
+function noteTrustKeySkipped(sessionName, state, key, reason, startedIn) {
+    (0, launch_answer_skips_1.noteLaunchAnswerSkipped)(logger, state.skips, TRUST_KEY_SKIPPED, { sessionName, key, reason }, startedIn);
+    state.lastSkip = reason;
+}
 /**
  * One poll's answer to the folder-trust dialog (Issue #201 / #3078 / #3089).
  *
@@ -178,9 +243,12 @@ exports.CLAUDE_TRUST_DIALOG_EXITED = 'trust dialog: Claude Code exited to the sh
  * @param dialogScreen - ANSI-stripped pane output when the dialog is open, else null
  * @param state - Mutated in place
  * @param readMark - {@link instanceInputLaunchReadMark} taken before `dialogScreen` was captured
+ * @param screenLife - {@link instanceInputAnswerSkipLife} taken before `dialogScreen` was captured
+ *   (review 4211 P2): a decline judged on that screen alone (`cursor-unreadable`) is
+ *   recorded in the life it was read in, not the one after this function's awaits
  * @throws {SessionStartFailedError} When the move budget is spent
  */
-async function answerTrustDialog(sessionName, dialogScreen, state, readMark = (0, instance_input_lock_1.instanceInputLaunchReadMark)()) {
+async function answerTrustDialog(sessionName, dialogScreen, state, readMark = (0, instance_input_lock_1.instanceInputLaunchReadMark)(), screenLife = (0, instance_input_lock_1.instanceInputAnswerSkipLife)(sessionName)) {
     if (state.pollsSinceAnswer !== null)
         state.pollsSinceAnswer++;
     if (state.pollsSinceMove !== null)
@@ -192,23 +260,34 @@ async function answerTrustDialog(sessionName, dialogScreen, state, readMark = (0
         state.shellTellsExit = await paneCommandIsAgent(sessionName);
     }
     const keys = (0, cli_patterns_1.resolveClaudeTrustDialogKeys)(dialogScreen);
-    if (keys === null)
+    if (keys === null) {
+        // Review 4211 P2: the screen's life, taken before `paneCommandIsAgent`'s await. A
+        // session made again meanwhile makes this an old life's decline: its warn, no record.
+        noteTrustKeySkipped(sessionName, state, null, 'cursor-unreadable', screenLife);
         return;
+    }
     if (keys.length === 1) {
         // Cursor on Yes, on this very screen: the Issue #201 Enter.
         const due = state.pollsSinceAnswer === null ||
             (state.pollsSinceAnswer >= TRUST_DIALOG_REANSWER_POLLS && state.answers < TRUST_DIALOG_MAX_ANSWERS);
         if (!due)
             return;
+        // Issue #4211: the life the answer starts in, before its await.
+        const answerLife = (0, instance_input_lock_1.instanceInputAnswerSkipLife)(sessionName);
         try {
-            if (!(await sendTrustDialogKey(sessionName, readMark, 'Enter')))
+            const skipped = await sendTrustDialogKey(sessionName, readMark, 'Enter', state.skips);
+            if (skipped !== null) {
+                noteTrustKeySkipped(sessionName, state, 'Enter', skipped, answerLife);
                 return;
+            }
+            (0, launch_answer_skips_1.forgetLaunchAnswerSkip)(state.skips, TRUST_KEY_SKIPPED);
             state.pollsSinceAnswer = 0;
             state.answers++;
             logger.info('trust-dialog-detected', { keys: 'Enter', attempt: state.answers });
         }
         catch {
             // Left unhandled so a later poll answers the dialog again
+            noteTrustKeySkipped(sessionName, state, 'Enter', 'send-failed', answerLife);
         }
         return;
     }
@@ -218,15 +297,22 @@ async function answerTrustDialog(sessionName, dialogScreen, state, readMark = (0
     if (state.moves >= TRUST_DIALOG_MAX_MOVES) {
         throw new session_start_error_1.SessionStartFailedError('Claude Code', sessionName, exports.CLAUDE_TRUST_DIALOG_CURSOR_STUCK);
     }
+    // Issue #4211: the life the answer starts in, before its await.
+    const answerLife = (0, instance_input_lock_1.instanceInputAnswerSkipLife)(sessionName);
     try {
-        if (!(await sendTrustDialogKey(sessionName, readMark, keys[0])))
+        const skipped = await sendTrustDialogKey(sessionName, readMark, keys[0], state.skips);
+        if (skipped !== null) {
+            noteTrustKeySkipped(sessionName, state, keys[0], skipped, answerLife);
             return;
+        }
+        (0, launch_answer_skips_1.forgetLaunchAnswerSkip)(state.skips, TRUST_KEY_SKIPPED);
         state.pollsSinceMove = 0;
         state.moves++;
         logger.info('trust-dialog-cursor-move', { key: keys[0], attempt: state.moves });
     }
     catch {
         // Left unhandled so a later poll moves the cursor again
+        noteTrustKeySkipped(sessionName, state, keys[0], 'send-failed', answerLife);
     }
 }
 /**
@@ -235,9 +321,13 @@ async function answerTrustDialog(sessionName, dialogScreen, state, readMark = (0
  * the read the key was decided on (`readMark`) and the lock, the dialog is read
  * again and the key goes out only if that screen still calls for it.
  *
- * @returns Whether the key was sent; false when it was not (the next poll decides again)
+ * Issue #4211: `repeatScope` is the wait's record, so the lock's own warn of a
+ * decline (`instance-input-answer-*`) is once per streak, as the nudge's is (#4189).
+ *
+ * @param repeatScope - The wait's {@link LaunchAnswerSkips}
+ * @returns null when the key was sent, otherwise why not (the next poll decides again)
  */
-async function sendTrustDialogKey(sessionName, readMark, key) {
+async function sendTrustDialogKey(sessionName, readMark, key, repeatScope) {
     const outcome = await (0, instance_input_lock_1.answerUnderInstanceInputLock)(sessionName, readMark, async () => {
         const screen = await getCleanPaneOutput(sessionName);
         if (!(0, cli_patterns_1.isClaudeTrustDialogOpen)(screen))
@@ -246,10 +336,8 @@ async function sendTrustDialogKey(sessionName, readMark, key) {
         if (keys === null)
             return false;
         return key === 'Enter' ? keys.length === 1 : keys.length > 1 && keys[0] === key;
-    }, () => (key === 'Enter' ? (0, tmux_1.sendKeys)(sessionName, '', true) : (0, tmux_1.sendSpecialKeys)(sessionName, [key])), { mode: 'exclusive' });
-    if (!outcome.answered)
-        logger.info('trust-dialog-key-skipped', { key, reason: outcome.reason });
-    return outcome.answered;
+    }, () => (key === 'Enter' ? (0, tmux_1.sendKeys)(sessionName, '', true) : (0, tmux_1.sendSpecialKeys)(sessionName, [key])), { mode: 'exclusive', repeatScope });
+    return outcome.answered ? null : outcome.reason;
 }
 /**
  * Whether the pane's foreground process is a shell again (Issue #3089). A
@@ -711,13 +799,17 @@ async function startClaudeSession(options) {
         const startTime = Date.now();
         let initialized = false;
         // Issue #3078 / #3089: the trust dialog's progress this start.
-        const trust = { pollsSinceAnswer: null, pollsSinceMove: null, answers: 0, moves: 0, seen: false, shellTellsExit: false };
+        const trust = { pollsSinceAnswer: null, pollsSinceMove: null, answers: 0, moves: 0, lastSkip: null, skips: (0, launch_answer_skips_1.newLaunchAnswerSkips)(), seen: false, shellTellsExit: false };
+        // Issue #4149: what the budget ran out on.
+        let lastScreen = null;
         while (Date.now() - startTime < maxWaitTime) {
             await new Promise((resolve) => setTimeout(resolve, pollInterval));
             // SF-001: Use getCleanPaneOutput helper (DRY)
             let cleanOutput = null;
             // Issue #3975: before the read the trust keys are decided on.
             const readMark = (0, instance_input_lock_1.instanceInputLaunchReadMark)();
+            // Review 4211 P2: the life the screen is read in, for a decline judged on it alone.
+            const screenLife = (0, instance_input_lock_1.instanceInputAnswerSkipLife)(sessionName);
             try {
                 cleanOutput = await getCleanPaneOutput(sessionName);
             }
@@ -727,11 +819,12 @@ async function startClaudeSession(options) {
             if (cleanOutput === null) {
                 continue;
             }
+            lastScreen = cleanOutput;
             // Issue #201 / #3078 / #3089: answer the folder-trust dialog. Checked
             // BEFORE the prompt: the dialog's cursor row (`❯ No, exit`) wears the
             // prompt glyph, so an open dialog is never read as a ready prompt.
             const trustDialogOpen = (0, cli_patterns_1.isClaudeTrustDialogOpen)(cleanOutput);
-            await answerTrustDialog(sessionName, trustDialogOpen ? cleanOutput : null, trust, readMark);
+            await answerTrustDialog(sessionName, trustDialogOpen ? cleanOutput : null, trust, readMark, screenLife);
             // Claude is ready when we see the prompt (DRY-001)
             // Use CLAUDE_PROMPT_PATTERN from cli-patterns.ts for consistency
             // Note: CLAUDE_SEPARATOR_PATTERN was removed from initialization check (Issue #187, P1-1)
@@ -775,7 +868,7 @@ async function startClaudeSession(options) {
         // carried to the caller by the error type rather than lost in a generic
         // message (CONS-005, IMP-001).
         if (!initialized) {
-            throw new session_start_error_1.SessionStartTimeoutError('Claude Code', sessionName, exports.CLAUDE_INIT_TIMEOUT);
+            throw startTimeoutError(sessionName, lastScreen, trust);
         }
         logger.info('started-claude-session');
     }
@@ -815,6 +908,9 @@ async function sendMessageToClaude(worktreeId, message, instanceId) {
     // (`❯ ` can pass for Claude's prompt) — wait for that launch, or, holding the
     // input lock as the send service does, refuse with nothing typed (R1).
     await (0, session_launch_flight_1.settleSessionLaunch)(sessionName, 'Claude Code');
+    // Issue #4134: a process already parked on this dialog starts no launch, so
+    // nothing else answers it and the prompt wait below could only time out.
+    await (0, claude_auto_default_nudge_1.answerClaudeAutoDefaultNudgeBeforeSend)(sessionName);
     await (0, session_key_sender_1.sendMessageToSession)(sessionName, message, exports.CLAUDE_POST_PROMPT_DELAY, exports.CLAUDE_SEND_PROMPT_WAIT_TIMEOUT, 
     // Issue #4048: the instance this send is for, so the first prompt's hook
     // check reads that instance's entry — the same one the name resolves to.

package/dist/server/src/lib/session/instance-input-lock.js

@@ -56,7 +56,9 @@
  * @module lib/session/instance-input-lock
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InputBoundaryRefusedError = exports.INPUT_BOUNDARY_REFUSED_CODE = exports.InstanceInputSessionReplacedError = exports.InstanceInputOwnershipLostError = exports.InstanceInputLockTimeoutError = exports.INSTANCE_INPUT_OWNERSHIP_LOST_CODE = exports.INSTANCE_INPUT_SESSION_REPLACED_CODE = exports.INSTANCE_INPUT_LOCK_TIMEOUT_CODE = exports.CARRIED_PASTE_MARK_TTL_MS = exports.LATE_PASTE_OBSERVE_MS = exports.INSTANCE_INPUT_LOCK_WAIT_MS = void 0;
+exports.InputBoundaryRefusedError = exports.INPUT_BOUNDARY_REFUSED_CODE = exports.ANSWER_SKIP_RECORD_MAX = exports.InstanceInputSessionReplacedError = exports.InstanceInputOwnershipLostError = exports.InstanceInputLockTimeoutError = exports.INSTANCE_INPUT_OWNERSHIP_LOST_CODE = exports.INSTANCE_INPUT_SESSION_REPLACED_CODE = exports.INSTANCE_INPUT_LOCK_TIMEOUT_CODE = exports.CARRIED_PASTE_MARK_TTL_MS = exports.LATE_PASTE_OBSERVE_MS = exports.INSTANCE_INPUT_LOCK_WAIT_MS = void 0;
+exports.instanceInputAnswerSkipLife = instanceInputAnswerSkipLife;
+exports.isInstanceInputAnswerSkipLife = isInstanceInputAnswerSkipLife;
 exports.currentInstanceInputTicket = currentInstanceInputTicket;
 exports.withInstanceInputLock = withInstanceInputLock;
 exports.instanceInputReadMark = instanceInputReadMark;
@@ -198,6 +200,80 @@ function noteSharedRelease() {
  */
 const revokedTickets = (0, global_state_1.getOrInitGlobal)('__instanceInputRevoked', () => new WeakSet());
 const ownerScope = (0, global_state_1.getOrInitGlobal)('__instanceInputOwnerScope', () => new node_async_hooks_1.AsyncLocalStorage());
+/** How many sessions' lives {@link answerSkipLives} keeps (Issue #4175). */
+exports.ANSWER_SKIP_RECORD_MAX = 256;
+const answerSkipLives = (0, global_state_1.getOrInitGlobal)('__instanceInputAnswerSkipLives', () => ({ seq: 0, droppedUpTo: 0, bySession: new Map() }));
+/** Each scope's records, by session. */
+const answerSkipRecords = new WeakMap();
+function answerSkipLifeNow(sessionName) {
+    return { known: answerSkipLives.bySession.get(sessionName) ?? null, seq: answerSkipLives.seq };
+}
+/** Whether `sessionName` is still in the life `life` was taken in. */
+function stillAnswerSkipLife(sessionName, life) {
+    const current = answerSkipLives.bySession.get(sessionName);
+    if (life.known !== null)
+        return current === life.known;
+    return current === undefined && answerSkipLives.droppedUpTo <= life.seq;
+}
+function beginAnswerSkipLife(sessionName) {
+    const lives = answerSkipLives;
+    lives.seq += 1;
+    lives.bySession.delete(sessionName);
+    lives.bySession.set(sessionName, lives.seq);
+    while (lives.bySession.size > exports.ANSWER_SKIP_RECORD_MAX) {
+        const oldest = lives.bySession.entries().next().value;
+        if (oldest === undefined)
+            break;
+        lives.bySession.delete(oldest[0]);
+        lives.droppedUpTo = Math.max(lives.droppedUpTo, oldest[1]);
+    }
+}
+/** Read-only (Issue #4189): {@link InstanceInputAnswerSkipLife} as it stands now. */
+function instanceInputAnswerSkipLife(sessionName) {
+    return answerSkipLifeNow(sessionName);
+}
+/** Read-only (Issue #4189): whether the session is still in the life `life` was taken in. */
+function isInstanceInputAnswerSkipLife(sessionName, life) {
+    return stillAnswerSkipLife(sessionName, life);
+}
+/** The scope's record for the session, if it is of the life this answer is in. */
+function answerSkipRecordOf(scope, sessionName, life) {
+    if (!stillAnswerSkipLife(sessionName, life))
+        return undefined;
+    const record = answerSkipRecords.get(scope)?.get(sessionName);
+    return record !== undefined && stillAnswerSkipLife(sessionName, record.life) ? record : undefined;
+}
+function putAnswerSkipRecord(scope, sessionName, record) {
+    let bySession = answerSkipRecords.get(scope);
+    if (bySession === undefined) {
+        bySession = new Map();
+        answerSkipRecords.set(scope, bySession);
+    }
+    bySession.set(sessionName, record);
+}
+/** Write a decline's warn unless the scope's streak is already this reason. */
+function warnAnswerSkip(event, sessionName, scope, life, reason, fields) {
+    if (scope === undefined) {
+        logger.warn(event, fields);
+        return;
+    }
+    if (answerSkipRecordOf(scope, sessionName, life)?.reason === reason) {
+        logger.debug(event, { ...fields, repeated: true });
+        return;
+    }
+    logger.warn(event, fields);
+    // An answer of an older life writes nothing for the new one.
+    if (stillAnswerSkipLife(sessionName, life))
+        putAnswerSkipRecord(scope, sessionName, { life, reason });
+}
+/** A decline that is not a warn (`target-changed`), or an answer that went through, ends the streak. */
+function endAnswerSkipStreak(sessionName, scope, life, reason) {
+    if (scope === undefined)
+        return;
+    const record = answerSkipRecordOf(scope, sessionName, life);
+    if (record !== undefined)
+        record.reason = reason;
+}
 function entryOf(sessionName) {
     let entry = entries.get(sessionName);
     if (entry === undefined) {
@@ -413,12 +489,18 @@ function skipOfLockError(error) {
  * compared before admission there, since the launch's own admission moves it,
  * and `readMark` is {@link instanceInputLaunchReadMark}, so a `shared` answer
  * that finished after the launch's read also makes it read again (review P2-1).
+ *
+ * Issue #4175: `repeatScope` — one object per wait that asks again on every poll —
+ * makes a decline's warn once while the same reason goes on in that scope (see
+ * {@link ANSWER_SKIP_RECORD_MAX}'s record). Without it every decline is a warn.
  */
 async function answerUnderInstanceInputLock(sessionName, readMark, stillApplies, answer, options = {}) {
     // A context that already owns the composer (a send's own readiness wait)
     // has held it since before its read: it joins, and nothing is read again.
     const joined = currentInstanceInputTicket(sessionName) !== null;
     const mode = options.mode ?? 'shared';
+    const scope = options.repeatScope;
+    const life = answerSkipLifeNow(sessionName);
     const movedBeforeAdmission = (mode === 'exclusive' ? instanceInputLaunchReadMark() : instanceInputReadMark()) !== readMark;
     let admitted = false;
     try {
@@ -432,7 +514,7 @@ async function answerUnderInstanceInputLock(sessionName, readMark, stillApplies,
                     applies = await stillApplies();
                 }
                 catch (error) {
-                    logger.warn('instance-input-answer-recheck-failed', {
+                    warnAnswerSkip('instance-input-answer-recheck-failed', sessionName, scope, life, 'recheck-failed', {
                         sessionName,
                         error: error instanceof Error ? error.message : String(error),
                     });
@@ -440,12 +522,15 @@ async function answerUnderInstanceInputLock(sessionName, readMark, stillApplies,
                 }
                 if (!applies) {
                     logger.info('instance-input-answer-target-changed', { sessionName, generation: ticket.generation });
+                    endAnswerSkipStreak(sessionName, scope, life, 'target-changed');
                     return { answered: false, reason: 'target-changed' };
                 }
             }
             if (!ticket.isCurrent())
                 return { answered: false, reason: 'input-lock-lost' };
-            return { answered: true, value: await answer(ticket) };
+            const value = await answer(ticket);
+            endAnswerSkipStreak(sessionName, scope, life, null);
+            return { answered: true, value };
         }, { waitMs: options.waitMs, mode });
     }
     catch (error) {
@@ -454,7 +539,7 @@ async function answerUnderInstanceInputLock(sessionName, readMark, stillApplies,
         const skip = admitted ? null : skipOfLockError(error);
         if (skip === null)
             throw error;
-        logger.warn('instance-input-answer-not-admitted', { sessionName, reason: skip });
+        warnAnswerSkip('instance-input-answer-not-admitted', sessionName, scope, life, skip, { sessionName, reason: skip });
         return { answered: false, reason: skip };
     }
 }
@@ -533,6 +618,8 @@ async function waitOutCarriedPasteMark(ticket) {
  * pane it just created.
  */
 function invalidateInstanceInput(sessionName) {
+    // Issue #4175: the new process's first declined answer is a warn of its own.
+    beginAnswerSkipLife(sessionName);
     const entry = entries.get(sessionName);
     if (entry === undefined)
         return;
@@ -706,4 +793,6 @@ function resetInstanceInputLocks() {
             clearTimeout(waiter.timer);
     }
     entries.clear();
+    answerSkipLives.bySession.clear();
+    answerSkipLives.droppedUpTo = answerSkipLives.seq;
 }