commandmate 0.47.2 → 0.49.0

package/dist/server/src/lib/polling/response-checker-dialog-gate.js

@@ -6,10 +6,13 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isWithheldForWantOfReceipt = isWithheldForWantOfReceipt;
+exports.isAntigravityGenericReadingOnScreen = isAntigravityGenericReadingOnScreen;
 exports.isNumberedDialogVouched = isNumberedDialogVouched;
 const logger_1 = require("../../lib/logger");
 const logger = (0, logger_1.createLogger)('response-poller');
 const antigravity_receipt_episodes_1 = require("./antigravity-receipt-episodes");
+const dialog_1 = require("../../lib/detection/tools/antigravity/dialog");
+const auto_yes_option_effect_1 = require("./auto-yes-option-effect");
 // Issue #2457: the same rollout table, `hasDialogRules` cross-check and
 // `detectDialog` seam Auto-Yes reads, reached through the presence helper rather
 // than through `evaluateAutoYesDialogGate` — see `isNumberedDialogVouched`.
@@ -44,6 +47,42 @@ function isWithheldForWantOfReceipt(scope) {
     });
     return true;
 }
+/**
+ * Does the screen itself show that the generic parser's agy reading is one
+ * CommandMate may answer? (Issue #3881, the second half: finding 8)
+ *
+ * Asked by the answering entry (`detectPromptOnCleanFrame` with a receipt
+ * scope) only for a reading agy's own reader did not take and
+ * `isAntigravityUnansweredNumberedScreen` let through — in practice a reply's
+ * plain `1. … N.` list (#1928's legacy reading). Before this, such a list was
+ * answered whenever agy's hook had recorded a tool call a moment earlier
+ * (#2849). The receipt says a tool call happened; it says nothing about
+ * whether THIS list is that call's approval UI, so on its own it is not
+ * evidence. The screen must show some:
+ *
+ * - agy's `/feedback` menu (its own footer under the options), the generic
+ *   reading #2364 left in place;
+ * - option rows agy's measured permission wording reads as (`Yes`, `Yes, run
+ *   command`, `Yes, and always allow …` — `auto-yes-option-effect`).
+ *
+ * The heading (`Requesting permission for:` / `Do you want to proceed?`), the
+ * `>` cursor and the `↑/↓ Navigate` footer are the other evidence, and a frame
+ * that shows them reaches no generic reading: agy's reader answers it, or
+ * `isAntigravityUnansweredNumberedScreen` declines it (#3808, #3818).
+ *
+ * A yes/no reading is not a numbered list and is left as it was.
+ *
+ * @param cleanOutput - The frame the reading came off (ANSI and box drawing stripped)
+ * @param reading - The generic parser's reading of it
+ */
+function isAntigravityGenericReadingOnScreen(cleanOutput, reading) {
+    const promptData = reading.promptData;
+    if (promptData?.type !== 'multiple_choice')
+        return true;
+    if ((0, dialog_1.isAntigravityFeedbackMenuScreen)(cleanOutput))
+        return true;
+    return (0, auto_yes_option_effect_1.selectAllowOnceOption)(promptData.options, 'antigravity').kind !== 'not-a-permission-dialog';
+}
 /**
  * Is the generic parser's numbered-list candidate a dialog the tool vouches for?
  * (Issue #2457)

package/dist/server/src/lib/polling/response-checker.js

@@ -63,23 +63,15 @@ const prompt_push_gate_1 = require("../../lib/push/prompt-push-gate");
 // Issue #2000: deep path for the same reason as the two imports above.
 const failure_push_notifier_1 = require("../../lib/push/failure-push-notifier");
 const upstream_faults_1 = require("../../lib/detection/upstream-faults");
+const realtime_snippet_1 = require("../../lib/realtime-snippet");
 const waiting_push_notifier_1 = require("../../lib/push/waiting-push-notifier");
+const waiting_episode_binding_1 = require("../../lib/session/waiting-episode-binding");
 const waiting_episode_state_1 = require("../../lib/session/waiting-episode-state");
+const waiting_screen_reading_1 = require("../../lib/detection/waiting-screen-reading");
+const auto_yes_state_1 = require("../../lib/auto-yes-state");
+const auto_yes_poller_state_1 = require("./auto-yes-poller-state");
 const task_transition_service_1 = require("../../lib/tasks/task-transition-service");
 const response_checker_blank_response_1 = require("./response-checker-blank-response");
-/**
- * How many rows from the bottom of a capture the upstream-fault check reads
- * (Issue #2000).
- *
- * The same 100 as `current-output-builder`'s `realtimeSnippet`, and for the
- * reason #1839 gives there: the wider capture keeps a banner from an hour ago
- * in scope, and "is this happening now" is the only question worth ringing a
- * phone about. Keeping the two windows equal also means the notification and
- * the `upstreamFault` field an operator reads in `capture --json` are judging
- * the same rows — a fault that rang but is invisible in the payload next to it
- * is unverifiable.
- */
-const UPSTREAM_FAULT_SCAN_ROWS = 100;
 /**
  * Raise a push notification when this frame shows a NEW upstream fault
  * (Issue #2000).
@@ -96,8 +88,17 @@ const UPSTREAM_FAULT_SCAN_ROWS = 100;
  * anything, so the level can be handed over on every poll.
  */
 function observeUpstreamFaultForPush(worktreeId, cliToolId, instanceId, output) {
-    const snippet = output.split('\n').slice(-UPSTREAM_FAULT_SCAN_ROWS).join('\n');
-    const match = (0, upstream_faults_1.matchUpstreamFault)(snippet);
+    // The rows `current-output-builder` publishes as `realtimeSnippet` and judges
+    // `upstreamFault` on (#1839), cut by the same function rather than a copy of
+    // its window. The reason is #1839's: the wider capture keeps a banner from an
+    // hour ago in scope, and "is this happening now" is the only question worth
+    // ringing a phone about. Sharing the cut also means the notification and the
+    // `upstreamFault` an operator reads in `capture --json` judge the same rows —
+    // a fault that rang but is invisible in the payload next to it is
+    // unverifiable. Issue #3936: the plain last 100 rows (#2000) drifted from the
+    // snippet when #2768 anchored it to the last row with content, so an inline
+    // codex pane showed `model-capacity` in the capture and never rang.
+    const match = (0, upstream_faults_1.matchUpstreamFault)((0, realtime_snippet_1.buildRealtimeSnippet)(output));
     // Fire-and-forget, like every other push call in this file: the poller must
     // not slow down or break because a notification could not be delivered.
     void (0, failure_push_notifier_1.notifyUpstreamFaultPush)({
@@ -154,6 +155,7 @@ function broadcastPromptSweptToAnswered(worktreeId) {
 // the one that calls `detectPrompt`, and only this file may import
 // `@/lib/tmux/tmux-capture-cache` (.eslintrc.json `no-restricted-imports`).
 const response_checker_extraction_result_1 = require("./response-checker-extraction-result");
+const prompt_screen_reading_1 = require("./prompt-screen-reading");
 var response_checker_extraction_result_2 = require("./response-checker-extraction-result");
 Object.defineProperty(exports, "incompleteResult", { enumerable: true, get: function () { return response_checker_extraction_result_2.incompleteResult; } });
 Object.defineProperty(exports, "buildPromptExtractionResult", { enumerable: true, get: function () { return response_checker_extraction_result_2.buildPromptExtractionResult; } });
@@ -197,8 +199,10 @@ const response_checker_extraction_steps_1 = require("./response-checker-extracti
  * @param receiptScope - whose frame this is, when the caller answers it
  *   automatically (Issue #2849). For agy only: a frame that reads as a prompt is
  *   then handed back as no prompt unless agy asked CommandMate about a tool call
- *   for that instance a moment ago. Omitted, the reading is not gated — which is
- *   what every caller that only DISPLAYS the frame wants.
+ *   for that instance a moment ago — and (Issue #3881) a generic numbered
+ *   reading also needs evidence on the screen itself
+ *   (`isAntigravityGenericReadingOnScreen`). Omitted, the reading is not gated —
+ *   which is what every caller that only DISPLAYS the frame wants.
  * @param frame - the SAME tick's `normalizeFrame(raw, cliToolId)`, when the
  *   caller built one (Issue #3183). The Auto-Yes poller builds it once and hands
  *   the same object to the dialog gate, so the quotation veto below and the gate
@@ -235,7 +239,13 @@ function detectPromptOnCleanFrame(cleanOutput, cliToolId, precomputedLines, rawF
         // reads `> 1. Google OAuth` as an answerable option. Judged without the
         // footer, so a missing footer cannot reopen the generic path. The status
         // verdict publishes the same frame as unclassified (`tools/antigravity/detect.ts`).
-        if ((0, dialog_1.isAntigravityUnvouchedNumberedScreen)(cleanOutput)) {
+        //
+        // Issue #3818: and by default — a numbered agy screen keeps the generic
+        // reading only as `/feedback` or as a reply's plain `1. … N.` list, so a
+        // run with a number missing or its `>` row off the pane is no prompt either.
+        // The status verdict keeps #3808's narrower rule: these frames still read
+        // as someone waiting there, they are only not answered from here.
+        if ((0, dialog_1.isAntigravityUnansweredNumberedScreen)(cleanOutput)) {
             return { isPrompt: false, cleanContent: cleanOutput.trim() };
         }
     }
@@ -293,6 +303,14 @@ function detectPromptOnCleanFrame(cleanOutput, cliToolId, precomputedLines, rawF
     if (cliToolId === 'antigravity' && result.isPrompt && (0, response_checker_dialog_gate_1.isWithheldForWantOfReceipt)(receiptScope)) {
         return { isPrompt: false, cleanContent: cleanOutput.trim() };
     }
+    // Issue #3881 (finding 8): and with a receipt, the receipt alone does not
+    // vouch for a generic reading — a reply's plain numbered list is answered
+    // only when the screen itself shows a known menu or agy's permission rows.
+    // Only for the caller that answers (a receipt scope); a display keeps it.
+    if (cliToolId === 'antigravity' && result.isPrompt && receiptScope !== undefined
+        && !(0, response_checker_dialog_gate_1.isAntigravityGenericReadingOnScreen)(cleanOutput, result)) {
+        return { isPrompt: false, cleanContent: cleanOutput.trim() };
+    }
     return result;
 }
 /**
@@ -615,6 +633,24 @@ function extractCompletedTurn(ctx, output, lastCapturedLine, owns) {
     }
     return { result, isFullScreenTui, lineCountIsCursor };
 }
+/**
+ * The episode a committed prompt observation left this wait in (Issue #3798):
+ * the one kept or rebound, the one the commit just opened or put in place, or
+ * null when the commit changed nothing.
+ */
+function committedEpisodeId(plan, committed) {
+    const obs = plan.observation;
+    switch (committed) {
+        case 'kept':
+        case 'rebound':
+            return plan.episodeId;
+        case 'opened':
+        case 'replaced':
+            return (0, waiting_episode_state_1.getWaitingEpisodeRecord)(obs.worktreeId, obs.cliToolId, obs.instanceId)?.episodeId ?? null;
+        default:
+            return null;
+    }
+}
 /**
  * Save a live prompt as a prompt message, and raise what follows from it: the
  * task event, the push notification and the waiting episode.
@@ -627,9 +663,11 @@ function extractCompletedTurn(ctx, output, lastCapturedLine, owns) {
  * @param promptDetection - The detection that passed the #2457 gate
  * @param result - The complete extraction this tick made
  * @param isFullScreenTui - True for opencode and copilot, which keep polling after a prompt
+ * @param frameTime - When the frame this prompt was read on was fetched (Issue #3798)
+ * @param frame - The capture the prompt was read on, for the stored reading (Issue #3881)
  * @returns What `checkForResponse` returns for this tick
  */
-function savePromptMessage(ctx, promptDetection, result, isFullScreenTui) {
+function savePromptMessage(ctx, promptDetection, result, isFullScreenTui, frameTime, frame) {
     const { db, worktree, worktreeId, cliToolId, instanceId, resolvedInstanceId, pollerKey } = ctx;
     // Issue #3701: the question #3663 / #3684 ask, for the prompt a tick retired
     // during the capture's `await` then finds on the pane — no row, broadcast,
@@ -646,6 +684,34 @@ function savePromptMessage(ctx, promptDetection, result, isFullScreenTui) {
         });
         return false;
     }
+    // Issue #3798 (design 規則 8): what this prompt does to the waiting episode,
+    // decided BEFORE the dedup below registers its hash. A frame fetched before
+    // the close of the very confirmation it shows — an answer and a stop landed
+    // during the capture — is not a new wait: nothing is saved, registered or
+    // pushed, and the next tick's frame decides. Planned against the state as it
+    // is now (`freshPrompt`), not as the tick found it. With the Auto-Yes
+    // poller's last answer (PR 3): another confirmation in the wait it answered
+    // is a new wait (R1-7), with a hold of its own rather than the spent one.
+    const plan = (0, waiting_episode_binding_1.planWaitingObservation)({
+        worktreeId,
+        cliToolId,
+        instanceId,
+        observer: 'response-checker',
+        start: ctx.observationStart,
+        reading: (0, waiting_screen_reading_1.promptWaitingReading)(promptDetection.promptData ?? null),
+        ...frameTime,
+        freshPrompt: true,
+        lastAnswer: (0, auto_yes_poller_state_1.getAutoYesLastAnswer)((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId)),
+    });
+    if (plan.action === 'ignored') {
+        logger.info('prompt-observation-stale', {
+            worktreeId,
+            cliToolId,
+            instanceId: resolvedInstanceId,
+            because: plan.ignoredBecause,
+        });
+        return false;
+    }
     // Issue #565: Content hash-based duplicate prompt prevention
     const promptContent = promptDetection.rawContent || promptDetection.cleanContent;
     const normalizedForDedup = (0, prompt_dedup_1.normalizePromptForDedup)(promptContent, cliToolId);
@@ -670,6 +736,9 @@ function savePromptMessage(ctx, promptDetection, result, isFullScreenTui) {
         }
         return false;
     }
+    // Issue #3881 (review P2-1): whether the frame's first row is the pane's —
+    // the capture was taken with `CACHE_MAX_CAPTURE_LINES` (`checkForResponse`).
+    const captureTop = (0, prompt_screen_reading_1.captureTopOf)(frame, tmux_capture_cache_1.CACHE_MAX_CAPTURE_LINES, cliToolId);
     // Issue #571: Clean TUI decorations from Copilot prompt content before saving
     let promptSaveContent = promptContent;
     if (cliToolId === 'copilot') {
@@ -683,7 +752,13 @@ function savePromptMessage(ctx, promptDetection, result, isFullScreenTui) {
         role: 'assistant',
         content: promptSaveContent,
         messageType: 'prompt',
-        promptData: promptDetection.promptData,
+        // Issue #3881: with what the frame was read as — the kind, the live rows,
+        // the target's completeness — so the chat transcript and every later
+        // reader take it as stated instead of deciding it again from the strings.
+        // Review P2-1: the capture window says whether the frame's top is the
+        // pane's (`captureTop`, and `top-unknown` on a target that reached a cut top),
+        // as the Auto-Yes poller reads its own frame.
+        promptData: (0, prompt_screen_reading_1.promptDataForStorage)(cliToolId, frame, (0, prompt_screen_reading_1.withCaptureTopCompleteness)(promptDetection, captureTop), captureTop),
         timestamp: new Date(),
         cliToolId,
         instanceId: resolvedInstanceId,
@@ -701,19 +776,19 @@ function savePromptMessage(ctx, promptDetection, result, isFullScreenTui) {
     // Fire-and-forget — push is advisory and must never block/break the poller.
     //
     // Issue #1790: the wait is now named by #1786's episode rather than by the
-    // prompt text. The two lines below are ordered, not incidental:
-    //
-    //  1. the notification is raised first, while it still has the prompt's
-    //     own question to quote — it records the episode in the dedup, so
-    //     whichever path reports the wait second says nothing;
-    //  2. `observeWaitingEdge` then opens that same episode, which is what
-    //     lets the edge listener (and #1788's WebSocket frame) agree with this
-    //     call about *which* wait this is instead of raising a second one.
-    //
-    // Both use one timestamp so the episode the notification claims and the
-    // episode the store opens are the same number.
-    const promptObservedAt = Date.now();
-    const promptWaitingSince = (0, waiting_episode_state_1.getWaitingEpisode)(worktreeId, cliToolId, instanceId)?.since ?? promptObservedAt;
+    // prompt text. Issue #3798: and by the episode's id, which the store gives
+    // a wait only when it opens or replaces one. So the observation is committed
+    // first and the notification raised with the id the commit settled on —
+    // the kept or rebound wait's, or the one just opened — inside
+    // `fanOutAfterCommit`, which holds the edge listener's own gate back until
+    // this fan-out is done: the notification that quotes the prompt's question
+    // still records the episode in the dedup first, and the listener (and
+    // #1788's WebSocket frame) agree with it about *which* wait this is — the
+    // same id to the gate's hold and suppression record, the dedup and the
+    // card's order. A commit that changed nothing (the episode moved since the
+    // plan) names no id, and the plan's `since` decides as before.
+    // No `await` from the plan to the commit.
+    const promptWaitingSince = plan.since ?? plan.at;
     // Issue #1999: Auto-Yes is a declaration that this session's prompts are
     // answered without a human, so notifying for one is telling the reader the
     // opposite of the truth. Only the notification is gated — the episode
@@ -721,30 +796,27 @@ function savePromptMessage(ctx, promptDetection, result, isFullScreenTui) {
     // reminder all see the wait exactly as they did before. The gate runs
     // before the call rather than inside it because `shouldSendWaitingPush`
     // records the episode the moment it decides to send.
-    if (!(0, prompt_push_gate_1.isPromptPushSuppressed)({
-        worktreeId,
-        cliToolId,
-        instanceId,
-        waitingSince: promptWaitingSince,
-    })) {
-        void (0, push_1.notifyPushSubscribers)({
+    (0, waiting_push_notifier_1.fanOutAfterCommit)({ worktreeId, cliToolId, instanceId }, () => (0, waiting_episode_binding_1.commitWaitingObservation)(plan), (committed) => {
+        const waitingEpisodeId = committedEpisodeId(plan, committed);
+        if (!(0, prompt_push_gate_1.isPromptPushSuppressed)({
             worktreeId,
-            worktreeName: worktree.name,
-            kind: 'prompt',
-            agentName: resolvedInstanceId,
-            instanceId: resolvedInstanceId,
-            waitingKind: 'prompt',
+            cliToolId,
+            instanceId,
             waitingSince: promptWaitingSince,
-            excerpt: promptDetection.promptData?.question ?? promptSaveContent,
-        }).catch(() => { });
-    }
-    (0, waiting_episode_state_1.observeWaitingEdge)({
-        worktreeId,
-        cliToolId,
-        instanceId,
-        waiting: true,
-        kind: 'prompt',
-        now: promptObservedAt,
+            waitingEpisodeId,
+        })) {
+            void (0, push_1.notifyPushSubscribers)({
+                worktreeId,
+                worktreeName: worktree.name,
+                kind: 'prompt',
+                agentName: resolvedInstanceId,
+                instanceId: resolvedInstanceId,
+                waitingKind: 'prompt',
+                waitingSince: promptWaitingSince,
+                waitingEpisodeId,
+                excerpt: promptDetection.promptData?.question ?? promptSaveContent,
+            }).catch(() => { });
+        }
     });
     if (!isFullScreenTui) {
         (0, response_poller_core_1.stopPolling)(worktreeId, cliToolId, instanceId);
@@ -1203,7 +1275,18 @@ async function recordCompletedResponse(ctx, turn, claudeMetadata, cleanedRespons
     // API, and every later prompt would be folded into that stale episode and
     // silently deduped. Nothing to close is a no-op, and no notification is
     // raised for a closing edge.
-    (0, waiting_episode_state_1.observeWaitingEdge)({ worktreeId, cliToolId, instanceId, waiting: false });
+    //
+    // Issue #3798: only the episode this tick started against — one that opened
+    // or moved while the reader and the log ran is not this reply's to end.
+    (0, waiting_episode_binding_1.observeWaiting)({
+        worktreeId,
+        cliToolId,
+        instanceId,
+        observer: 'response-checker',
+        start: ctx.observationStart,
+        reading: { kind: 'not-waiting' },
+        frameCapturedAt: 0,
+    });
     // Web Push fan-out (Issue #1125): session completed (running → idle).
     // Fire-and-forget — push is advisory and must never block/break the poller.
     void (0, push_1.notifyPushSubscribers)({
@@ -1256,6 +1339,8 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
             instanceId,
             resolvedInstanceId,
             pollerKey,
+            // Issue #3798: before the tick's first `await`.
+            observationStart: (0, waiting_episode_binding_1.startWaitingObservation)(worktreeId, cliToolId, instanceId),
         };
         // Check if CLI tool session is running
         const running = await (0, cli_session_1.isSessionRunning)(worktreeId, cliToolId, instanceId);
@@ -1320,7 +1405,9 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
         // Capture current output. The requested width IS the capture window, so it is
         // taken from the same constant extractResponse() measures saturation against
         // (Issue #1670) — a literal here would silently decouple the two.
-        const output = await (0, cli_session_1.captureSessionOutput)(worktreeId, cliToolId, tmux_capture_cache_1.CACHE_MAX_CAPTURE_LINES, instanceId);
+        // Issue #3798: dated by where that frame came from — from the cache, it may
+        // be older than this tick.
+        const { frame: output, frameTime } = await (0, waiting_episode_binding_1.captureObservedFrame)(() => (0, cli_session_1.captureSessionOutput)(worktreeId, cliToolId, tmux_capture_cache_1.CACHE_MAX_CAPTURE_LINES, instanceId));
         // Issue #3705: there is no `await` from here to the transcript reader
         // inside the save path, so this one answer covers every write in between —
         // the fault notifier, the TUI accumulator, the prompt sweep, the skip
@@ -1360,7 +1447,7 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
             if (owns)
                 (0, response_dedup_1.resetDuplicateResponseSkipStreak)(pollerKey);
             // Asks for itself (#3701), before the prompt dedup.
-            return savePromptMessage(ctx, promptDetection, result, isFullScreenTui);
+            return savePromptMessage(ctx, promptDetection, result, isFullScreenTui, frameTime, output);
         }
         // Issue #3538: a finished frame without a live prompt ends the run of
         // duplicate prompt ticks, as an unfinished one does in `extractCompletedTurn`.

package/dist/server/src/lib/prompt-answer-sender.js

@@ -665,7 +665,7 @@ async function recaptureAfterKeys(sessionName) {
  * @throws {MultiSelectAnswerRejectedError} whenever the question was not
  *   committed; `keysSent` says whether the pane was touched.
  */
-async function sendCommandCodeMultiSelectAnswer(sessionName, promptData, wanted, stillCurrent) {
+async function sendCommandCodeMultiSelectAnswer(sessionName, promptData, wanted, stillCurrent, touch) {
     const cursor = promptData.options.find((option) => option.isDefault === true);
     if (cursor === undefined) {
         throw new MultiSelectAnswerRejectedError('cursor-unknown', false, wanted);
@@ -679,7 +679,7 @@ async function sendCommandCodeMultiSelectAnswer(sessionName, promptData, wanted,
         ...current.filter((n) => !wanted.includes(n)),
     ].sort((a, b) => a - b);
     if (toggles.length > 0) {
-        await sendSpecialKeysWhileCurrent(sessionName, toggles.map(String), stillCurrent);
+        await sendSpecialKeysWhileCurrent(sessionName, toggles.map(String), stillCurrent, touch);
     }
     const keysSent = toggles.length > 0;
     // 2. Read the screen back and refuse unless it is the same question with
@@ -712,7 +712,7 @@ async function sendCommandCodeMultiSelectAnswer(sessionName, promptData, wanted,
     if (cursorNow === undefined) {
         throw new MultiSelectAnswerRejectedError('cursor-unknown', keysSent, wanted);
     }
-    await sendSpecialKeysWhileCurrent(sessionName, [...downKeys(verified.options.length - cursorNow.number + 1), 'Enter'], stillCurrent);
+    await sendSpecialKeysWhileCurrent(sessionName, [...downKeys(verified.options.length - cursorNow.number + 1), 'Enter'], stillCurrent, touch);
     // 4. The second stage. `Submit` opens the Review page and the answer is sent
     //    from there; `Next` advances to the following question, which IS the
     //    commit for this one (its tab turns `✔`).
@@ -728,7 +728,7 @@ async function sendCommandCodeMultiSelectAnswer(sessionName, promptData, wanted,
         if (review.hasUnansweredWarning) {
             throw new MultiSelectAnswerRejectedError('review-unanswered', true, wanted);
         }
-        await sendSpecialKeysWhileCurrent(sessionName, ['Enter'], stillCurrent);
+        await sendSpecialKeysWhileCurrent(sessionName, ['Enter'], stillCurrent, touch);
         return;
     }
     const next = (0, dialog_1.readCommandCodeQuestionDialog)(afterConfirm);
@@ -756,6 +756,50 @@ class PromptAnswerAbortedError extends Error {
     }
 }
 exports.PromptAnswerAbortedError = PromptAnswerAbortedError;
+/**
+ * What the tmux call that failed did (Issue #3880), when the error came from
+ * the transport (`TmuxSendError`, by name: test doubles of `./tmux/tmux` need
+ * not export the class); null for any other error.
+ */
+function transportDeliveryOf(error) {
+    if (!(error instanceof Error) || error.name !== 'TmuxSendError')
+        return null;
+    const delivery = error.delivery;
+    return delivery === 'not-started' || delivery === 'indeterminate' ? delivery : null;
+}
+/**
+ * A failure after a key reached the pane says so (Issue #3839): `keysSent: true`
+ * is put on it, as on {@link PromptAnswerAbortedError}, so Auto-Yes does not
+ * type the answer again over what is already there. An error that already
+ * names `keysSent` (the refusals and the stop above) keeps its own word, and a
+ * failure before any key is left as it was.
+ *
+ * Issue #3880: a transport failure also gets `answerDelivery` ({@link AnswerDelivery};
+ * the tmux error's own `delivery` is that one call's).
+ * `indeterminate` — the tmux call ended without an exit status, and its key may
+ * be on the pane — is NOT `keysSent: true` (no key is known to be there; the
+ * ledger counts it `failed`, #3820) but Auto-Yes holds it all the same. A
+ * transport refusal before any key is `keysSent: false`: known not sent, free
+ * to be sent again.
+ */
+function withKeysSent(error, touch) {
+    if (!(error instanceof Error))
+        return error;
+    const transport = transportDeliveryOf(error);
+    if (transport !== null) {
+        const answerDelivery = transport === 'indeterminate' ? 'indeterminate' : touch.touched ? 'delivered' : 'not-started';
+        Object.assign(error, { answerDelivery });
+    }
+    if ('keysSent' in error)
+        return error;
+    if (touch.touched) {
+        Object.assign(error, { keysSent: true });
+    }
+    else if (transport === 'not-started') {
+        Object.assign(error, { keysSent: false });
+    }
+    return error;
+}
 /** Stop here when the caller's `stillCurrent` says no (Issue #3706). */
 function assertStillCurrent(stillCurrent, keysSent) {
     if (stillCurrent && !stillCurrent())
@@ -766,13 +810,32 @@ function assertStillCurrent(stillCurrent, keysSent) {
  * gave one (Issue #3706). Without it the call is exactly the old two-argument
  * one, so manual answers and every other caller send as before.
  */
-async function sendSpecialKeysWhileCurrent(sessionName, keys, stillCurrent) {
+async function sendSpecialKeysWhileCurrent(sessionName, keys, stillCurrent, touch) {
     if (!stillCurrent) {
-        await (0, tmux_1.sendSpecialKeys)(sessionName, keys);
+        try {
+            await (0, tmux_1.sendSpecialKeys)(sessionName, keys);
+        }
+        catch (error) {
+            // Issue #3880: without `shouldContinue` the count comes from the error.
+            if (touch && keysDeliveredOf(error) > 0)
+                touch.touched = true;
+            throw error;
+        }
+        if (touch && keys.length > 0)
+            touch.touched = true;
         return;
     }
+    // Issue #3839: `shouldContinue` is asked after each key but the last, so the
+    // times it was asked are the keys known to have reached the pane when a
+    // later one fails.
+    let delivered = 0;
     try {
-        await (0, tmux_1.sendSpecialKeys)(sessionName, keys, { shouldContinue: stillCurrent });
+        await (0, tmux_1.sendSpecialKeys)(sessionName, keys, {
+            shouldContinue: () => {
+                delivered++;
+                return stillCurrent();
+            },
+        });
     }
     catch (error) {
         // By name rather than `instanceof`: test doubles of `./tmux/tmux` need not
@@ -780,8 +843,22 @@ async function sendSpecialKeysWhileCurrent(sessionName, keys, stillCurrent) {
         if (error instanceof Error && error.name === 'SpecialKeysAbortedError') {
             throw new PromptAnswerAbortedError(true);
         }
+        if (touch && Math.max(delivered, keysDeliveredOf(error)) > 0)
+            touch.touched = true;
         throw error;
     }
+    if (touch && keys.length > 0)
+        touch.touched = true;
+}
+/**
+ * The keys a failed `sendSpecialKeys` says tmux took before the one that
+ * failed (Issue #3880, `TmuxSendError.keysDelivered`); 0 when it says none.
+ */
+function keysDeliveredOf(error) {
+    if (!(error instanceof Error) || error.name !== 'TmuxSendError')
+        return 0;
+    const count = error.keysDelivered;
+    return typeof count === 'number' && Number.isFinite(count) && count > 0 ? count : 0;
 }
 /**
  * Send an answer to a tmux session, using cursor-key navigation for
@@ -791,8 +868,22 @@ async function sendSpecialKeysWhileCurrent(sessionName, keys, stillCurrent) {
  * This function unifies the logic previously duplicated in:
  * - src/app/api/worktrees/[id]/prompt-response/route.ts (L114-187)
  * - src/lib/auto-yes-manager.ts (L340-399)
+ *
+ * A failure after a key of the answer reached the pane carries `keysSent: true`
+ * (Issue #3839), and a transport failure its `answerDelivery` (Issue #3880);
+ * see {@link withKeysSent}.
  */
 async function sendPromptAnswer(params) {
+    const touch = { touched: false };
+    try {
+        await sendPromptAnswerKeys(params, touch);
+    }
+    catch (error) {
+        throw withKeysSent(error, touch);
+    }
+}
+/** {@link sendPromptAnswer}, noting in `touch` each key that reached the pane. */
+async function sendPromptAnswerKeys(params, touch) {
     const { sessionName, answer, cliToolId, promptData, fallbackPromptType, fallbackDefaultOptionNumber, stillCurrent } = params;
     // Issue #2755: Command Code's checkbox question, before every guard below.
     // Its answer is a SET (`"1,3"`), which none of them can read — `/^\d+$/` is
@@ -803,7 +894,7 @@ async function sendPromptAnswer(params) {
     // a two-stage confirm, not a digit and an Enter.
     const multiSelect = readMultiSelectRequest(params);
     if (multiSelect !== null) {
-        await sendCommandCodeMultiSelectAnswer(sessionName, multiSelect.promptData, multiSelect.wanted, stillCurrent);
+        await sendCommandCodeMultiSelectAnswer(sessionName, multiSelect.promptData, multiSelect.wanted, stillCurrent, touch);
         (0, tmux_capture_cache_1.invalidateCache)(sessionName);
         return;
     }
@@ -874,7 +965,7 @@ async function sendPromptAnswer(params) {
             keys.push(...buildNavigationKeys(downToNext));
             // 4. Enter to submit
             keys.push('Enter');
-            await sendSpecialKeysWhileCurrent(sessionName, keys, stillCurrent);
+            await sendSpecialKeysWhileCurrent(sessionName, keys, stillCurrent, touch);
         }
         else {
             // Single-select: navigate and Enter to select
@@ -892,12 +983,15 @@ async function sendPromptAnswer(params) {
             const keys = (isAskUserQuestionPicker && offset === 0)
                 ? ['Down', 'Up', 'Enter']
                 : [...navigationKeys, 'Enter'];
-            await sendSpecialKeysWhileCurrent(sessionName, keys, stillCurrent);
+            await sendSpecialKeysWhileCurrent(sessionName, keys, stillCurrent, touch);
         }
     }
     else {
         // Standard CLI prompt: send text + Enter (y/n, Approve?, etc.)
         await (0, tmux_1.sendKeys)(sessionName, answer, false);
+        // Issue #3839: the text is on the pane; a failed Enter after it says so.
+        if (answer !== '')
+            touch.touched = true;
         // Issue #616: Resolve submitMode and determine whether to suppress Enter
         const resolvedSubmitMode = resolveSubmitMode(params, dialog);
         if (!shouldSuppressEnter(params, resolvedSubmitMode, dialog)) {

package/dist/server/src/lib/push/notification-dedup.js

@@ -60,15 +60,28 @@ const waitingSent = (0, global_state_1.getOrInitGlobal)('__waitingPushDedup', ()
  *  - the escalation → allowed exactly once per episode;
  *  - a new episode (the wait ended and another began) → sent again, even if the
  *    prompt text and the elapsed time are identical.
+ *
+ * Issue #3798: "the same episode" is the mixed rule `prompt-push-gate` holds
+ * its hold by — both ids present and equal, or one absent and the `since`s
+ * equal. Kept inline rather than imported: this module stays a leaf.
  */
 function shouldSendWaitingPush(event) {
     const key = `${event.worktreeId}::${event.instanceId}`;
     const escalated = event.escalated === true;
+    const episodeId = event.episodeId ?? undefined;
     const prev = waitingSent.get(key);
-    if (prev && prev.since === event.since && (prev.escalated || !escalated)) {
+    const sameEpisode = prev !== undefined &&
+        (prev.episodeId !== undefined && episodeId !== undefined
+            ? prev.episodeId === episodeId
+            : prev.since === event.since);
+    if (prev && sameEpisode && (prev.escalated || !escalated)) {
+        // An id-less producer recorded this wait first; it is named now.
+        if (prev.episodeId === undefined && episodeId !== undefined)
+            prev.episodeId = episodeId;
         return false;
     }
-    waitingSent.set(key, { since: event.since, escalated });
+    const recordedId = episodeId ?? (sameEpisode ? prev?.episodeId : undefined);
+    waitingSent.set(key, { since: event.since, ...(recordedId !== undefined ? { episodeId: recordedId } : {}), escalated });
     return true;
 }
 /** Clear the episode-scoped state (for tests). */