commandmate 0.46.1 → 0.47.2

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

@@ -16,6 +16,8 @@ exports.isSessionRunning = isSessionRunning;
 exports.getSessionPresence = getSessionPresence;
 exports.captureSessionOutput = captureSessionOutput;
 exports.captureSessionOutputFresh = captureSessionOutputFresh;
+exports.sendSessionAnswerKey = sendSessionAnswerKey;
+exports.readSessionPaneCommand = readSessionPaneCommand;
 exports.getSessionName = getSessionName;
 exports.publishSessionSurface = publishSessionSurface;
 exports.forgetSessionSurface = forgetSessionSurface;
@@ -115,7 +117,8 @@ async function captureSessionOutput(worktreeId, cliToolId, lines = 1000, instanc
  * Capture CLI session output bypassing cache (fresh capture).
  *
  * Issue #405: Used by prompt-response endpoint to ensure fresh output
- * for prompt re-verification. Writes back to cache on success.
+ * for prompt re-verification. Writes back to cache on success, unless the
+ * session was invalidated while the capture was in flight (Issue #3734).
  *
  * @param worktreeId - Worktree ID
  * @param cliToolId - CLI tool ID
@@ -127,11 +130,16 @@ async function captureSessionOutputFresh(worktreeId, cliToolId, lines = 5000, in
     log.debug('captureSessionOutputFresh:start', { requestedLines: lines });
     const { cliTool, sessionName } = resolveSessionContext(worktreeId, cliToolId, instanceId);
     const transport = getDefaultTransport();
+    // Issue #3734: snapshot the generation before the capture starts
+    const generation = (0, tmux_capture_cache_1.getCaptureGeneration)(sessionName);
     try {
         const output = await transport.captureSnapshot(sessionName, { startLine: -lines });
-        // Write back to cache if non-empty [SEC4-007]
+        // Write back to cache if non-empty [SEC4-007]. Skip it when the session was
+        // invalidated while waiting: the output may predate a send (Issue #3734).
         if (output.length > 0) {
-            (0, tmux_capture_cache_1.setCachedCapture)(sessionName, output, lines);
+            if ((0, tmux_capture_cache_1.isCaptureGenerationCurrent)(sessionName, generation)) {
+                (0, tmux_capture_cache_1.setCachedCapture)(sessionName, output, lines);
+            }
         }
         else {
             (0, tmux_capture_cache_1.invalidateCache)(sessionName);
@@ -146,6 +154,33 @@ async function captureSessionOutputFresh(worktreeId, cliToolId, lines = 5000, in
         throw new Error(`Failed to capture ${cliTool.name} output: ${errorMessage}`);
     }
 }
+/**
+ * Send ONE answer key to a session and drop its cached capture, so the next
+ * read is of the pane after the key (Issue #3756). One key per call: the
+ * strict `respond` reads the screen again between two keys.
+ */
+async function sendSessionAnswerKey(worktreeId, cliToolId, key, instanceId) {
+    if (key !== 'Up' && key !== 'Down' && key !== 'Enter') {
+        throw new Error(`Unsupported answer key: ${String(key)}`);
+    }
+    const { sessionName } = resolveSessionContext(worktreeId, cliToolId, instanceId);
+    try {
+        await (0, tmux_1.sendSpecialKeys)(sessionName, [key]);
+    }
+    finally {
+        (0, tmux_capture_cache_1.invalidateCache)(sessionName);
+    }
+}
+/**
+ * The foreground command of a session's pane (`#{pane_current_command}`), or
+ * null when tmux cannot say (Issue #3788). The strict `respond` reads it after
+ * its Enter: agy exits on the trust screen's `No, exit` and leaves the shell in
+ * a pane that is still up, which only this tells apart from an unread screen.
+ */
+async function readSessionPaneCommand(worktreeId, cliToolId, instanceId) {
+    const { sessionName } = resolveSessionContext(worktreeId, cliToolId, instanceId);
+    return (0, tmux_1.getPaneCurrentCommand)(sessionName);
+}
 /**
  * Get session name for a CLI tool and worktree
  *

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

@@ -0,0 +1,155 @@
+"use strict";
+/**
+ * The last send attempt per instance (Issue #3759).
+ *
+ * When the first message of a session did not arrive (#3746:
+ * `Antigravity prompt not ready`), nothing said whether it was still to be
+ * sent, already on the pane, or somewhere in between. This module keeps, per
+ * (worktree, tool, instance), how the last {@link sendUserMessage} attempt
+ * ended — `not-sent` / `sent` / `indeterminate` (`./send-attempt-types`) — and
+ * `prompt --json` publishes it as `lastSend`.
+ *
+ * The record carries a digest of the message, never the message: it says which
+ * message the state is about without keeping what was written.
+ *
+ * Nothing here resends. The sender (a person, or the supervising agent) decides,
+ * and an `indeterminate` message is not to be resent before looking at the pane.
+ *
+ * In memory on `globalThis` (the send route and the observing route are bundled
+ * apart under `next dev`), bounded; a restart forgets every record, which
+ * publishes as "no record", never as a state.
+ *
+ * Recording must never change a send's outcome: {@link recordSendAttempt}
+ * swallows its own failures.
+ *
+ * @module lib/session/send-attempt-state
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendMessageDigest = sendMessageDigest;
+exports.recordSendAttempt = recordSendAttempt;
+exports.getLastSendAttempt = getLastSendAttempt;
+exports.clearSendAttempts = clearSendAttempts;
+exports.classifySendFailure = classifySendFailure;
+exports.composerHoldsMessage = composerHoldsMessage;
+exports.describeSendAttemptState = describeSendAttemptState;
+const crypto_1 = require("crypto");
+const global_state_1 = require("../../lib/global-state");
+const logger_1 = require("../../lib/logger");
+const session_start_error_1 = require("../../lib/session/session-start-error");
+const send_attempt_types_1 = require("./send-attempt-types");
+const logger = (0, logger_1.createLogger)('session/send-attempt-state');
+/** How many instances are tracked at once; the least recently sent to is forgotten first. */
+const MAX_TRACKED_INSTANCES = 1024;
+const records = (0, global_state_1.getOrInitGlobal)('__sendAttemptRecords', () => new Map());
+function keyOf(instance) {
+    return JSON.stringify([instance.worktreeId, instance.cliToolId, instance.instanceId]);
+}
+/** The digest a record carries for `content`. */
+function sendMessageDigest(content) {
+    return (0, crypto_1.createHash)('sha256').update(content, 'utf8').digest('hex').slice(0, 16);
+}
+/**
+ * Record how a send attempt ended. Never throws: a record that cannot be made
+ * leaves the send exactly as it was.
+ */
+function recordSendAttempt(instance, attempt, now = Date.now()) {
+    try {
+        const key = keyOf(instance);
+        // Re-inserted, so the map's order is least recently sent to first.
+        records.delete(key);
+        records.set(key, {
+            at: Math.floor(now),
+            state: attempt.state,
+            reason: attempt.reason,
+            messageDigest: sendMessageDigest(attempt.content),
+        });
+        while (records.size > MAX_TRACKED_INSTANCES) {
+            const oldest = records.keys().next().value;
+            if (oldest === undefined)
+                break;
+            records.delete(oldest);
+        }
+    }
+    catch (error) {
+        logger.warn('send-attempt-record-failed', { error: error instanceof Error ? error.message : String(error) });
+    }
+}
+/** The instance's last recorded attempt, or null when none is held. */
+function getLastSendAttempt(instance) {
+    return records.get(keyOf(instance)) ?? null;
+}
+/** Forget every record (tests). */
+function clearSendAttempts() {
+    records.clear();
+}
+/**
+ * Where a failed `ICLITool.sendMessage` stopped, read from its error.
+ *
+ * Only failures whose wording says the body was never typed are `not-sent`;
+ * every other failure is `indeterminate`, because "we do not know" must never
+ * read as "safe to resend". The tools wrap these messages
+ * (`Failed to send message to <tool>: …`), so they are matched anywhere in it.
+ */
+function classifySendFailure(error) {
+    if (typeof error === 'object' &&
+        error !== null &&
+        error.code === session_start_error_1.SESSION_STARTING_CODE) {
+        return { state: 'not-sent', reason: 'session-starting' };
+    }
+    // #3772: the plan review overlay refused the send before the body was typed.
+    if (typeof error === 'object' &&
+        error !== null &&
+        error.code === send_attempt_types_1.PLAN_REVIEW_SEND_REFUSED_CODE) {
+        return { state: 'not-sent', reason: 'plan-review' };
+    }
+    const message = error instanceof Error ? error.message : String(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).
+    if (/still holds unsent text after \d+ clear passes/.test(message)) {
+        return { state: 'not-sent', reason: 'composer-not-empty' };
+    }
+    // #2464 / #3366: typed, never submitted, taken back out best-effort.
+    if (/Enter was not pressed, so nothing was submitted/.test(message)) {
+        return { state: 'indeterminate', reason: 'body-not-landed' };
+    }
+    // #1501: the input line was cleared best-effort.
+    if (/replaced by a TUI autocompletion/.test(message)) {
+        return { state: 'indeterminate', reason: 'replaced-by-completion' };
+    }
+    // #1471: typed, Enter sent (more than once), never confirmed.
+    if (/submit could not be confirmed/i.test(message)) {
+        return { state: 'indeterminate', reason: 'submit-unconfirmed' };
+    }
+    return { state: 'indeterminate', reason: 'send-error' };
+}
+/** The whitespace-free form two renderings of one text share. */
+function compact(text) {
+    return text.replace(/\s+/g, '');
+}
+/**
+ * Whether a composer read (`extractComposerText(...).text`) still holds the
+ * message: its compacted text contains the compacted start of the message's
+ * first non-blank line. Only the start, because a long body is cut by the
+ * reader and wrapped by the TUI.
+ */
+function composerHoldsMessage(composerText, content) {
+    const firstLine = content.split('\n').find((line) => line.trim() !== '') ?? '';
+    const needle = compact(firstLine).slice(0, 32);
+    return needle !== '' && compact(composerText).includes(needle);
+}
+/** One line for a failed send's error: what state the message is in, and who resends it. */
+function describeSendAttemptState(attempt) {
+    if (attempt.state === 'not-sent') {
+        return (`[send state: not-sent (${attempt.reason}): the message was not typed. ` +
+            'CommandMate does not resend it; send it again once the input prompt is back ' +
+            '(`commandmate prompt <worktree-id> --json` shows the screen and lastSend).]');
+    }
+    if (attempt.state === 'indeterminate') {
+        return (`[send state: indeterminate (${attempt.reason}): part of the message may have been typed or submitted. ` +
+            'CommandMate does not resend it; do not resend before checking the pane ' +
+            '(`commandmate capture <worktree-id> --pane`), or it may arrive twice.]');
+    }
+    return `[send state: sent (${attempt.reason})]`;
+}

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

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * What the last send to an instance did to its pane (Issue #3759): types only.
+ *
+ * Kept free of imports so the CLI can read the payload's shape through
+ * `lib/prompt-observation/types` without pulling the server graph in (the same
+ * rule `polling/auto-yes-suppression-reason` follows).
+ *
+ * @module lib/session/send-attempt-types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+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';

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

@@ -533,7 +533,8 @@ function migrateRuntimeState(db, renames, result) {
         if (!runningAutoYesPollers.has(move.oldKey))
             continue;
         try {
-            (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) {

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

@@ -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