commandmate 0.46.0 → 0.47.0

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

@@ -29,6 +29,10 @@
  *   8. clearInProgressMessageId
  *   9. startPolling                  — record the assistant response afterwards
  *
+ * 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.
+ *
  * Out of scope (kept in the HTTP layer / caller): request/body validation,
  * content trimming/size limits, imagePath validation, CLI-tool availability
  * and session-start (running) checks. The caller passes already-validated input.
@@ -48,6 +52,10 @@ const worktree_session_ownership_1 = require("../../lib/cli-tools/worktree-sessi
 const session_name_1 = require("../../lib/cli-tools/session-name");
 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 composer_text_1 = require("../../lib/detection/composer-text");
+const status_capture_config_1 = require("../../config/status-capture-config");
 const opencode_1 = require("../../lib/cli-tools/opencode");
 const logger = (0, logger_1.createLogger)('session/send-user-message');
 function getErrorMessage(error) {
@@ -92,6 +100,28 @@ async function waitForPreviousTurnRecorded(worktreeId, resolvedInstanceId) {
     }
     return true;
 }
+/**
+ * Whether the composer still shows the message after a send whose submit was
+ * never confirmed (Issue #3759) — evidence that it is typed but unsent.
+ *
+ * Only for the composers `extractComposerText` has measured; any other tool,
+ * and any read that fails, answers false and the state stays
+ * `submit-unconfirmed`. Either way the state is `indeterminate`: a message in
+ * the composer is not one to type again.
+ */
+async function composerStillHolds(worktreeId, cliToolId, instanceId, content) {
+    if (!composer_text_1.SUPPORTED_COMPOSER_TOOLS.has(cliToolId))
+        return false;
+    try {
+        const output = await (0, cli_session_1.captureSessionOutputFresh)(worktreeId, cliToolId, status_capture_config_1.STATUS_CAPTURE_LINES, instanceId);
+        const read = (0, composer_text_1.extractComposerText)(output, cliToolId);
+        return read.state === 'content' && (0, send_attempt_state_1.composerHoldsMessage)(read.text, content);
+    }
+    catch (error) {
+        logger.warn('send-composer-residue-read-failed', { error: getErrorMessage(error) });
+        return false;
+    }
+}
 /**
  * Send a validated user message to the CLI tool and record it in history.
  *
@@ -111,6 +141,12 @@ async function sendUserMessage(db, params) {
      */
     const resolvedInstanceId = instanceId ?? cliToolId;
     const cliTool = manager_1.CLIToolManager.getInstance().getTool(cliToolId);
+    // Issue #3759: how this attempt left the message, kept for `lastSend` (and
+    // read back by the send route for its error). The result's shape is
+    // unchanged; recording never throws.
+    const settle = (state, reason) => {
+        (0, send_attempt_state_1.recordSendAttempt)({ worktreeId, cliToolId, instanceId: resolvedInstanceId }, { state, reason, content });
+    };
     // Issue #2865: the send route checks ownership itself, but the timer manager
     // and relay delivery reach tmux only through here. A session under this
     // worktree's name that was created in another directory belongs to another
@@ -119,6 +155,7 @@ async function sendUserMessage(db, params) {
     const sessionName = (0, session_name_1.resolveSessionName)(cliToolId, worktreeId, instanceId);
     const ownership = await (0, worktree_session_ownership_1.checkWorktreeSessionOwnership)(worktreeId, sessionName, db);
     if (ownership === null || ownership.verdict === 'foreign') {
+        settle('not-sent', 'foreign-session');
         logger.warn('send-refused-foreign-session', {
             worktreeId,
             cliToolId,
@@ -157,6 +194,7 @@ async function sendUserMessage(db, params) {
         ignoreStructured: params.ignoreStructuredPromptGuard,
     });
     if (promptGuard.waiting) {
+        settle('not-sent', 'prompt-waiting');
         logger.info('send-refused-prompt-waiting', {
             worktreeId,
             cliToolId,
@@ -194,6 +232,7 @@ async function sendUserMessage(db, params) {
         }
         catch (error) {
             logger.error('failed-to-send-model-command:', { error: getErrorMessage(error) });
+            settle('not-sent', '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
@@ -314,11 +353,18 @@ async function sendUserMessage(db, params) {
     }
     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' };
+        }
+        settle(failure.state, failure.reason);
         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');
     // 5. Create user message in database (History source: chat_messages).
     const message = (0, db_1.createMessage)(db, {
         worktreeId,

package/dist/server/src/lib/session/worktree-session-reconcile.js

@@ -86,6 +86,8 @@ const session_ownership_1 = require("../../lib/tmux/session-ownership");
 const control_mode_tmux_transport_1 = require("../../lib/tmux/control-mode-tmux-transport");
 const auto_yes_manager_1 = require("../../lib/polling/auto-yes-manager");
 const response_poller_1 = require("../../lib/polling/response-poller");
+const auto_yes_poller_state_1 = require("../../lib/polling/auto-yes-poller-state");
+const auto_yes_enter_fallback_1 = require("../../lib/polling/auto-yes-enter-fallback");
 const ws_server_1 = require("../../lib/ws-server");
 const logger_1 = require("../../lib/logger");
 const logger = (0, logger_1.createLogger)('worktree-session-reconcile');
@@ -152,8 +154,9 @@ function planSessionRenames(db, rename, errors) {
             // getSessionName validates already; assert it explicitly so the guarantee
             // is stated where the name is about to be handed to tmux (Issue #1621).
             (0, validation_1.validateSessionName)(newName);
-            if (oldName !== newName)
-                plans.push({ oldName, newName, rename, source: 'roster' });
+            if (oldName !== newName) {
+                plans.push({ oldName, newName, rename, cliToolId, instanceId, source: 'roster' });
+            }
         }
         catch (error) {
             errors.push(`session name for ${rename.oldId}/${instanceId}: ${error instanceof Error ? error.message : String(error)}`);
@@ -284,8 +287,16 @@ function discoverSessionRenames(renames, liveNames, knownIds, result) {
                 : attributed.cliToolId;
             const newName = tool.getSessionName(rename.newId, instanceId);
             (0, validation_1.validateSessionName)(newName);
-            if (name !== newName)
-                plans.push({ oldName: name, newName, rename, source: 'live' });
+            if (name !== newName) {
+                plans.push({
+                    oldName: name,
+                    newName,
+                    rename,
+                    cliToolId: attributed.cliToolId,
+                    instanceId,
+                    source: 'live',
+                });
+            }
         }
         catch (error) {
             result.errors.push(`attribute session ${name}: ${error instanceof Error ? error.message : String(error)}`);
@@ -374,6 +385,10 @@ function allocateTempName(taken, ordinal) {
 }
 /**
  * Rename the live tmux sessions in two stages so no intermediate state collides.
+ *
+ * @returns The plans whose session was renamed in BOTH stages (Issue #3713: a
+ *   stage-2 `false` — the session vanished from its temporary name — is not
+ *   one; it is reported as skipped).
  */
 async function renameSessionsTwoStage(plans, live, deps, result) {
     if (plans.length === 0)
@@ -426,7 +441,14 @@ async function renameSessionsTwoStage(plans, live, deps, result) {
     const completed = [];
     for (const { plan, tempName } of staged) {
         try {
-            await deps.renameSession(tempName, plan.newName);
+            if (!(await deps.renameSession(tempName, plan.newName))) {
+                result.skippedSessions.push({
+                    oldName: plan.oldName,
+                    newName: plan.newName,
+                    reason: 'session no longer exists',
+                });
+                continue;
+            }
             result.renamedSessions.push({ oldName: plan.oldName, newName: plan.newName });
             completed.push(plan);
             // The control-mode attach survived the rename; only the registry key is
@@ -453,6 +475,37 @@ async function renameSessionsTwoStage(plans, live, deps, result) {
     }
     return completed;
 }
+/** The Auto-Yes composite key of a plan's instance under `worktreeId`. */
+function autoYesKeyOf(plan, worktreeId) {
+    return (0, auto_yes_manager_1.buildCompositeKey)(worktreeId, plan.cliToolId, plan.instanceId);
+}
+/**
+ * Carry Auto-Yes's memory of an answer stopped part-way, and of a send still in
+ * flight, to the new key of each session that moved (Issue #3713).
+ *
+ * Only for the renames that succeeded in both stages: a refused, failed or
+ * vanished rename leaves the destination's live session — and its memory —
+ * alone. Not part of {@link migrateRuntimeState}, which still runs for every
+ * requested pair: a grant, a response poller or a WebSocket room is about the
+ * worktree, this memory is about one process.
+ */
+function moveAutoYesPartialAnswers(completed, sourceEpochs) {
+    const moves = [];
+    for (const plan of completed) {
+        const sourceEpoch = sourceEpochs.get(plan);
+        if (sourceEpoch === undefined)
+            continue;
+        moves.push({
+            oldKey: autoYesKeyOf(plan, plan.rename.oldId),
+            newKey: autoYesKeyOf(plan, plan.rename.newId),
+            sourceEpoch,
+        });
+    }
+    const received = (0, auto_yes_poller_state_1.movePartialAnswers)(moves);
+    if (received.length > 0) {
+        logger.info('reconcile:auto-yes-partial-answers-moved', { keys: received });
+    }
+}
 /**
  * Move the in-process state that is keyed on a worktree ID.
  *
@@ -468,15 +521,28 @@ function migrateRuntimeState(db, renames, result) {
     const runningAutoYesPollers = new Set((0, auto_yes_manager_1.getAutoYesPollerCompositeKeys)());
     const movedAutoYes = (0, auto_yes_manager_1.migrateAutoYesStateWorktreeIds)(renames);
     result.movedAutoYesKeys = movedAutoYes.map((move) => move.newKey);
+    // The poller's timer chain captures the worktree ID, so re-keying its map
+    // would leave it polling the old session. Stop and restart instead — the
+    // Auto-Yes *state* (deadline, stop pattern) is what must survive, and it
+    // already has. Every old poller is stopped before any successor starts
+    // (Issue #3713): in a swap (A↔B) with both running, stop A → start B would
+    // find B's own poller still there ("already_running"), and the stop B that
+    // follows would leave the B side with none.
+    const restarts = [];
     for (const move of movedAutoYes) {
         if (!runningAutoYesPollers.has(move.oldKey))
             continue;
         try {
-            // The poller's timer chain captures the worktree ID, so re-keying its map
-            // would leave it polling the old session. Stop and restart instead — the
-            // Auto-Yes *state* (deadline, stop pattern) is what must survive, and it
-            // already has.
-            (0, auto_yes_manager_1.stopAutoYesPolling)(move.oldKey);
+            // Issue #3730: a move, not a release — the grant goes on under newKey.
+            (0, auto_yes_manager_1.stopAutoYesPolling)(move.oldKey, 'worktree-id-migrated');
+            restarts.push(move);
+        }
+        catch (error) {
+            result.errors.push(`auto-yes poller ${move.newKey}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    for (const move of restarts) {
+        try {
             const started = (0, auto_yes_manager_1.startAutoYesPolling)(move.newWorktreeId, move.cliToolId, move.instanceId);
             if (started.started) {
                 result.restartedAutoYesPollers.push(move.newKey);
@@ -572,7 +638,15 @@ async function reconcileWorktreeSessions(db, renamesOrOldId, newIdOrOptions, may
                 result.planSources.discovered++;
         }
         const ownedPlans = excludeForeignSessionPlans(db, plans, live, livePaths, deps, result);
-        await renameSessionsTwoStage(ownedPlans, live, deps, result);
+        // Issue #3713: each source session's epoch, read before the first rename's
+        // await — a session begun under the old key while the renames run is not the
+        // one that moves, and its memory stays where it is.
+        const sourceEpochs = new Map(ownedPlans.map((plan) => [plan, (0, auto_yes_enter_fallback_1.getEnterFallbackSessionEpoch)(autoYesKeyOf(plan, plan.rename.oldId))]));
+        const completed = await renameSessionsTwoStage(ownedPlans, live, deps, result);
+        // No await between the renames and this: Auto-Yes's memory of an answer
+        // stopped part-way (and of a send still in flight) follows exactly the
+        // sessions that moved, before any poller restarts below.
+        moveAutoYesPartialAnswers(completed, sourceEpochs);
     }
     // Runtime state moves after the sessions: a poller that ticks in between
     // fails one capture against a name that is briefly gone, which is a logged

package/dist/server/src/lib/timer-manager.js

@@ -53,6 +53,13 @@ async function executeTimer(timerId) {
         const instanceId = timer.instanceId;
         // [Issue #539] Check if session is running before sending
         const isRunning = await cliTool.isRunning(timer.worktreeId, instanceId);
+        // [Issue #3707] A cancel can succeed while the await above is pending.
+        // Re-read synchronously (no await between this read and the update below,
+        // so better-sqlite3 makes read+update atomic) and bail out unless the
+        // timer is still pending; otherwise 'cancelled' would be overwritten.
+        const current = (0, timer_db_1.getTimerById)(db, timerId);
+        if (!current || current.status !== 'pending')
+            return;
         if (!isRunning) {
             logger.warn('timer:no-session', { timerId, worktreeId: timer.worktreeId, instanceId });
             (0, timer_db_1.updateTimerStatus)(db, timerId, timer_constants_1.TIMER_STATUS.NO_SESSION);

package/dist/server/src/lib/tmux/session-created-signal.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * "A tmux session of this name was just created" (Issue #3796).
+ *
+ * The Auto-Yes poller that found no session waits `MAX_BACKOFF_MS` for its next
+ * tick, and the push gate holds a prompt wait until that tick (#3791), so a
+ * session created right after the poller looked was answered — or its human
+ * notified — up to about 64 s late. {@link createSession} reports every session
+ * it creates here, and a waiting poller listens for its own session's name and
+ * ticks early.
+ *
+ * Synchronous and dependency-free on purpose: `tmux.ts` is the lowest layer and
+ * must not import the poller (it would be a cycle). A listener that throws is
+ * isolated from the others and from the session creation that fired it.
+ *
+ * @module lib/tmux/session-created-signal
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onTmuxSessionCreated = onTmuxSessionCreated;
+exports.notifyTmuxSessionCreated = notifyTmuxSessionCreated;
+exports.countTmuxSessionCreatedListeners = countTmuxSessionCreatedListeners;
+exports.clearTmuxSessionCreatedListeners = clearTmuxSessionCreatedListeners;
+const global_state_1 = require("../global-state");
+/**
+ * sessionName -> listeners. globalThis for the reason every shared in-memory
+ * state is (#1736): the creator (a route bundle) and the poller (the server's)
+ * can hold separate copies of this module.
+ */
+const listeners = (0, global_state_1.getOrInitGlobal)('__tmuxSessionCreatedListeners', () => new Map());
+/**
+ * Call `listener` the next time a session named `sessionName` is created.
+ *
+ * @returns Unsubscribe; calling it more than once does nothing
+ */
+function onTmuxSessionCreated(sessionName, listener) {
+    let set = listeners.get(sessionName);
+    if (set === undefined) {
+        set = new Set();
+        listeners.set(sessionName, set);
+    }
+    set.add(listener);
+    return () => {
+        const current = listeners.get(sessionName);
+        if (current === undefined)
+            return;
+        current.delete(listener);
+        if (current.size === 0)
+            listeners.delete(sessionName);
+    };
+}
+/** Tell the listeners of `sessionName` that it was created. Each one is called once and dropped. */
+function notifyTmuxSessionCreated(sessionName) {
+    const set = listeners.get(sessionName);
+    if (set === undefined)
+        return;
+    listeners.delete(sessionName);
+    for (const listener of set) {
+        try {
+            listener();
+        }
+        catch {
+            // A listener's failure must not fail the session creation that fired it.
+        }
+    }
+}
+/** Number of sessions someone is waiting for. Test seam. */
+function countTmuxSessionCreatedListeners() {
+    let n = 0;
+    for (const set of listeners.values())
+        n += set.size;
+    return n;
+}
+/** Drop every listener. Test seam. */
+function clearTmuxSessionCreatedListeners() {
+    listeners.clear();
+}

package/dist/server/src/lib/tmux/tmux-capture-cache.js

@@ -21,6 +21,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CACHE_MAX_CAPTURE_LINES = exports.CACHE_MAX_ENTRIES = exports.CACHE_TTL_MS = void 0;
 exports.isCaptureWindowSaturated = isCaptureWindowSaturated;
+exports.getCaptureGeneration = getCaptureGeneration;
+exports.isCaptureGenerationCurrent = isCaptureGenerationCurrent;
 exports.sliceOutput = sliceOutput;
 exports.getCachedCapture = getCachedCapture;
 exports.setCachedCapture = setCachedCapture;
@@ -85,6 +87,37 @@ function getCache() {
 function getInflight() {
     return (0, global_state_1.getOrInitGlobal)('__tmuxCaptureCacheInflight', () => new Map());
 }
+function getGenerationState() {
+    return (0, global_state_1.getOrInitGlobal)('__tmuxCaptureCacheGeneration', () => ({ global: 0, sessions: new Map() }));
+}
+// =========================================================================
+// getCaptureGeneration() / isCaptureGenerationCurrent()
+// =========================================================================
+/**
+ * Take the invalidation generation for a session before starting a capture
+ * (Issue #3734). Pass it to isCaptureGenerationCurrent() after the await.
+ *
+ * @param sessionName - tmux session name
+ * @returns Generation snapshot
+ */
+function getCaptureGeneration(sessionName) {
+    const state = getGenerationState();
+    return { global: state.global, session: state.sessions.get(sessionName) ?? 0 };
+}
+/**
+ * Whether no invalidateCache(sessionName) / clearAllCache() ran since the
+ * snapshot was taken (Issue #3734). A capture that started before the
+ * invalidation may show the screen from before a send, so it must not be
+ * written back to the cache.
+ *
+ * @param sessionName - tmux session name
+ * @param generation - Snapshot from getCaptureGeneration()
+ * @returns True when the capture may be written back
+ */
+function isCaptureGenerationCurrent(sessionName, generation) {
+    const current = getCaptureGeneration(sessionName);
+    return current.global === generation.global && current.session === generation.session;
+}
 // =========================================================================
 // sliceOutput()
 // =========================================================================
@@ -183,6 +216,9 @@ function setCachedCapture(sessionName, output, capturedLines) {
 // =========================================================================
 /**
  * Invalidate cache for a specific session.
+ * Issue #3734: also advances the session's generation and drops its inflight
+ * entry, so a capture started before the invalidation is neither written back
+ * nor joined by callers that arrive after it (they start a fresh capture).
  * [SEC4-006] Logs debug message with session name for troubleshooting.
  *
  * @param sessionName - tmux session name to invalidate
@@ -190,6 +226,9 @@ function setCachedCapture(sessionName, output, capturedLines) {
 function invalidateCache(sessionName) {
     const cache = getCache();
     cache.delete(sessionName);
+    const generations = getGenerationState().sessions;
+    generations.set(sessionName, (generations.get(sessionName) ?? 0) + 1);
+    getInflight().delete(sessionName);
     // [SEC4-006] Debug log for cache invalidation chain tracking
     logger.debug('cache:invalidate', { sessionName });
 }
@@ -197,14 +236,20 @@ function invalidateCache(sessionName) {
 // clearAllCache()
 // =========================================================================
 /**
- * Clear all cache entries and inflight requests.
- * Used for graceful shutdown.
+ * Clear all cache entries and inflight requests for every session.
+ * Called at the start of a worktree's session cleanup (session-cleanup.ts).
+ * Issue #3734: advances the global generation so captures started before the
+ * clear are not written back. Per-session counts are dropped here because the
+ * global generation alone already tells every older snapshot apart.
  */
 function clearAllCache() {
     const cache = getCache();
     cache.clear();
     const inflight = getInflight();
     inflight.clear();
+    const state = getGenerationState();
+    state.global += 1;
+    state.sessions.clear();
 }
 // =========================================================================
 // resetCacheForTesting()
@@ -216,6 +261,7 @@ function clearAllCache() {
 function resetCacheForTesting() {
     globalThis.__tmuxCaptureCache = undefined;
     globalThis.__tmuxCaptureCacheInflight = undefined;
+    globalThis.__tmuxCaptureCacheGeneration = undefined;
 }
 // =========================================================================
 // getOrFetchCapture() - singleflight pattern
@@ -247,18 +293,24 @@ async function getOrFetchCapture(sessionName, requestedLines, fetchFn) {
         return sliceOutput(result, requestedLines);
     }
     // 3. Create new fetch promise
+    // Issue #3734: snapshot the generation before fetchFn() starts
+    const generation = getCaptureGeneration(sessionName);
     const fetchPromise = fetchFn();
     inflight.set(sessionName, fetchPromise);
     try {
         const output = await fetchPromise;
-        // Cache non-empty results only [SEC4-007]
-        if (output.length > 0) {
+        // Cache non-empty results only [SEC4-007], and only when no invalidation
+        // happened while waiting (Issue #3734)
+        if (output.length > 0 && isCaptureGenerationCurrent(sessionName, generation)) {
             setCachedCapture(sessionName, output, exports.CACHE_MAX_CAPTURE_LINES);
         }
         return sliceOutput(output, requestedLines);
     }
     finally {
-        // Clean up inflight entry
-        inflight.delete(sessionName);
+        // Clean up inflight entry, unless an invalidation already replaced it
+        // with a newer fetch (Issue #3734)
+        if (inflight.get(sessionName) === fetchPromise) {
+            inflight.delete(sessionName);
+        }
     }
 }

package/dist/server/src/lib/tmux/tmux.js

@@ -4,7 +4,7 @@
  * Provides functions to manage tmux sessions for Claude CLI integration
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DIRECT_INPUT_TEXT_CHUNK_BYTES = exports.REPAINT_INVALIDATE_DELAY_MS = exports.NAVIGATION_KEY_VALUES = exports.SPECIAL_KEY_VALUES = void 0;
+exports.DIRECT_INPUT_TEXT_CHUNK_BYTES = exports.REPAINT_INVALIDATE_DELAY_MS = exports.NAVIGATION_KEY_VALUES = exports.SPECIAL_KEY_VALUES = exports.SpecialKeysAbortedError = void 0;
 exports.exactTarget = exactTarget;
 exports.reconcileSessionGeometry = reconcileSessionGeometry;
 exports.hasSession = hasSession;
@@ -31,6 +31,7 @@ const util_1 = require("util");
 const tmux_capture_cache_1 = require("./tmux-capture-cache");
 const geometry_delegation_1 = require("./geometry-delegation");
 const legacy_session_alias_1 = require("./legacy-session-alias");
+const session_created_signal_1 = require("./session-created-signal");
 const validation_1 = require("../../lib/cli-tools/validation");
 const tmux_pane_config_1 = require("../../config/tmux-pane-config");
 const logger_1 = require("../../lib/logger");
@@ -449,6 +450,9 @@ async function createSession(sessionNameOrOptions, cwd) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         throw new Error(`Failed to create tmux session: ${errorMessage}`);
     }
+    // Issue #3796: an Auto-Yes poller waiting for this session ticks now rather
+    // than a backoff later. Outside the try: a listener cannot fail the creation.
+    (0, session_created_signal_1.notifyTmuxSessionCreated)(sessionName);
 }
 /**
  * Send keys to a tmux session
@@ -577,6 +581,21 @@ function isSendableSpecialKey(key) {
 }
 /** Delay between individual key presses for TUI apps that need processing time (ms). */
 const SPECIAL_KEY_DELAY_MS = 100;
+/**
+ * {@link sendSpecialKeys} stopped between two keys because its
+ * `shouldContinue` said so (Issue #3706). Not wrapped in the transport error.
+ */
+class SpecialKeysAbortedError extends Error {
+    keysSent;
+    constructor(
+    /** How many keys reached tmux before the stop (always at least one). */
+    keysSent) {
+        super(`Special key sequence stopped after ${keysSent} key(s)`);
+        this.keysSent = keysSent;
+        this.name = 'SpecialKeysAbortedError';
+    }
+}
+exports.SpecialKeysAbortedError = SpecialKeysAbortedError;
 /**
  * Send tmux special keys (unquoted key names like Down, Up, Enter, Space).
  * Used for cursor-based navigation in CLI tool prompts (e.g., Claude Code AskUserQuestion).
@@ -587,9 +606,11 @@ const SPECIAL_KEY_DELAY_MS = 100;
  *
  * @param sessionName - Target session name
  * @param keys - Array of tmux special key names (e.g., ['Down', 'Down', 'Space', 'Enter'])
+ * @param options - Optional `shouldContinue`, asked after each delay (Issue #3706)
  * @throws {Error} If any key name is not in the allowed set, or if tmux command fails
+ * @throws {SpecialKeysAbortedError} If `shouldContinue` returned false between two keys
  */
-async function sendSpecialKeys(sessionName, keys) {
+async function sendSpecialKeys(sessionName, keys, options) {
     if (keys.length === 0)
         return;
     // Validate all keys are in the allowed set (command injection prevention)
@@ -604,10 +625,15 @@ async function sendSpecialKeys(sessionName, keys) {
             // Delay between key presses (skip after the last key)
             if (i < keys.length - 1) {
                 await new Promise(resolve => setTimeout(resolve, SPECIAL_KEY_DELAY_MS));
+                if (options?.shouldContinue && !options.shouldContinue()) {
+                    throw new SpecialKeysAbortedError(i + 1);
+                }
             }
         }
     }
     catch (error) {
+        if (error instanceof SpecialKeysAbortedError)
+            throw error;
         const errorMessage = error instanceof Error ? error.message : String(error);
         throw new Error(`Failed to send special keys to tmux session: ${errorMessage}`);
     }

package/dist/server/src/lib/verification/env-clean-gate.js

@@ -572,6 +572,7 @@ function diffEnvSnapshots(baseline, final, context, options = {}) {
                 removedByOtherRepository: [],
                 removedStaleDemoVitest: [],
                 ignoredByConfig: [],
+                ignoredBuiltIn: [],
             };
         }
         if (!after || after.status !== 'ok') {
@@ -587,18 +588,20 @@ function diffEnvSnapshots(baseline, final, context, options = {}) {
                 removedByOtherRepository: [],
                 removedStaleDemoVitest: [],
                 ignoredByConfig: [],
+                ignoredBuiltIn: [],
             };
         }
         const beforeKeys = new Set(before.entries.map((entry) => entry.key));
         const afterKeys = new Set(after.entries.map((entry) => entry.key));
         // Only `home-entries`, and only by the whole name: the same string under
         // `~/.commandmate` is a different directory and stays counted.
-        const isIgnoredByConfig = (entry) => probeId === 'home-entries' &&
-            (ignoredHomeEntries.has(entry.key) || isZcompdumpEntry(entry.key));
+        const isIgnoredByConfig = (entry) => probeId === 'home-entries' && ignoredHomeEntries.has(entry.key);
+        const isIgnoredBuiltIn = (entry) => probeId === 'home-entries' && isZcompdumpEntry(entry.key);
         const added = [];
         const ignoredAdded = [];
         const taskSessionAdded = [];
         const ignoredByConfig = [];
+        const ignoredBuiltIn = [];
         for (const entry of after.entries) {
             if (beforeKeys.has(entry.key))
                 continue;
@@ -607,6 +610,10 @@ function diffEnvSnapshots(baseline, final, context, options = {}) {
                 ignoredByConfig.push(toChange(entry, owner));
                 continue;
             }
+            if (isIgnoredBuiltIn(entry)) {
+                ignoredBuiltIn.push(toChange(entry, owner));
+                continue;
+            }
             if (probeId === 'tmux-sessions' && taskSession && entry.key === taskSession) {
                 // Additions only: a task session that existed at task start and is gone
                 // falls through to `removed` below like everything else (#1624).
@@ -632,6 +639,9 @@ function diffEnvSnapshots(baseline, final, context, options = {}) {
             if (isIgnoredByConfig(entry)) {
                 ignoredByConfig.push(change);
             }
+            else if (isIgnoredBuiltIn(entry)) {
+                ignoredBuiltIn.push(change);
+            }
             else if (tmuxServerSurvived &&
                 change.owner !== 'self' &&
                 otherServerSessions.has(entry.key)) {
@@ -661,6 +671,7 @@ function diffEnvSnapshots(baseline, final, context, options = {}) {
             removedByOtherRepository,
             removedStaleDemoVitest,
             ignoredByConfig,
+            ignoredBuiltIn,
         };
     });
     // A measured violation is a verdict and outranks an unmeasured probe; an
@@ -735,6 +746,20 @@ function formatIgnoredByConfig(changes) {
     const names = changes.map((change) => change.key).join(', ');
     return [`    ignored (options.envCleanIgnoreHomeEntries): ${names}`];
 }
+/** Built-in `home-entries` exclusions (zsh compinit cache), on their own line (#3672). */
+function formatIgnoredBuiltIn(changes) {
+    if (changes.length === 0)
+        return [];
+    const names = changes.map((change) => change.key).join(', ');
+    return [`    ignored (built-in): ${names}`];
+}
+/** Additions excused as another worktree's, named on a clean report (#3683). */
+function formatIgnoredAttributed(changes) {
+    if (changes.length === 0)
+        return [];
+    const names = changes.map((change) => change.key).join(', ');
+    return [`    ignored (attributed to another worktree): ${names}`];
+}
 /**
  * The header's account of what could be excused, so a report judged against a
  * baseline written before #2472 says why the task's own session was not.
@@ -765,6 +790,8 @@ function formatEnvCleanReport(diff) {
             lines.push(...formatRemovedByOtherRepository(probe.removedByOtherRepository));
             lines.push(...formatRemovedStaleDemoVitest(probe.removedStaleDemoVitest));
             lines.push(...formatIgnoredByConfig(probe.ignoredByConfig));
+            lines.push(...formatIgnoredBuiltIn(probe.ignoredBuiltIn));
+            lines.push(...formatIgnoredAttributed(probe.ignoredAdded));
             continue;
         }
         lines.push(`  ${probe.probeId} VIOLATED (${label}): +${probe.added.length} -${probe.removed.length}`);
@@ -775,6 +802,7 @@ function formatEnvCleanReport(diff) {
         lines.push(...formatRemovedByOtherRepository(probe.removedByOtherRepository));
         lines.push(...formatRemovedStaleDemoVitest(probe.removedStaleDemoVitest));
         lines.push(...formatIgnoredByConfig(probe.ignoredByConfig));
+        lines.push(...formatIgnoredBuiltIn(probe.ignoredBuiltIn));
         for (const excused of probe.ignoredAdded) {
             lines.push(`    · ${excused.key} (ignored: belongs to another worktree)`);
         }