commandmate 0.47.2 → 0.48.0

package/dist/server/src/lib/session/agent-event-turn.js

@@ -10,6 +10,9 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.reopenedTurns = exports.agentTurns = exports.generationStartedAt = void 0;
+exports.registerTurnOutcomeSink = registerTurnOutcomeSink;
+exports.toGenerationRef = toGenerationRef;
+exports.liveDecisionCount = liveDecisionCount;
 exports.currentGeneration = currentGeneration;
 exports.effectiveTurn = effectiveTurn;
 exports.livePendingDecisions = livePendingDecisions;
@@ -71,6 +74,38 @@ exports.reopenedTurns = (0, global_state_1.getOrInitGlobal)('__agentEventReopene
  * boundary rather than a cosmetic clash.
  */
 const turnSequence = (0, global_state_1.getOrInitGlobal)('__agentEventTurnSeq', () => ({ value: 0 }));
+/**
+ * Install the sink for outcomes this module produces outside a
+ * `recordAgentEvent` call. Registered by `waiting-episode-binding`, through
+ * `globalThis`, so this module imports nothing that imports it back.
+ */
+function registerTurnOutcomeSink(sink) {
+    globalThis.__agentEventTurnOutcomeSink = sink;
+}
+/** A generation as the waiting episode names it. */
+function toGenerationRef(generation) {
+    return generation === null ? { kind: 'none' } : { kind: 'opened', at: generation };
+}
+/** Live decisions held by a record, counted without retiring the expired ones. */
+function liveDecisionCount(turn, now) {
+    return turn.pendingDecisions.filter((decision) => (0, provisional_turn_1.isDecisionLive)(decision, now)).length;
+}
+/** Describe the instance's record before a transition rewrites it. */
+function describePrevious(turn, eventSessionId, at) {
+    if (turn === null)
+        return { kind: 'none' };
+    if (turn.closedAt !== null)
+        return { kind: 'closed', turnId: turn.turnId, closedBy: turn.closedBy ?? 'stop' };
+    if (turn.openedAt === null) {
+        const decisions = liveDecisionCount(turn, at);
+        return decisions > 0
+            ? { kind: 'dialog-only', turnId: turn.turnId, decisions, sessionId: turn.sessionId }
+            : { kind: 'display-only', turnId: turn.turnId };
+    }
+    return (0, provisional_turn_1.closesTurn)(turn, eventSessionId)
+        ? { kind: 'open-same-session', turnId: turn.turnId }
+        : { kind: 'open-other-session', turnId: turn.turnId };
+}
 // =============================================================================
 // Turn model (Issue #1930)
 // =============================================================================
@@ -283,10 +318,18 @@ function observeScraperCompletionEvidence(worktreeId, cliToolId, instanceId, com
  * were raised by a process that no longer exists, and answering one would
  * deliver a verdict into a slot nobody is holding.
  */
-function fenceTurnForNewGeneration(key, at) {
+function fenceTurnForNewGeneration(key, at, source = 'session-start') {
     const turn = exports.agentTurns.get(key);
+    // Issue #3798: reported whether or not a turn existed — the waiting episode
+    // is fenced by its own generation, not by the turn's.
+    const outcome = {
+        kind: 'generation-fenced',
+        source,
+        generation: toGenerationRef(currentGeneration(key)),
+        fencedTurnId: turn?.turnId ?? null,
+    };
     if (!turn)
-        return;
+        return outcome;
     evictDecisions(key, turn);
     // A turn that had ALREADY ended is left where it is, which means the fence in
     // `fencedTurn` hides it from here on. That asymmetry is deliberate: the
@@ -295,7 +338,7 @@ function fenceTurnForNewGeneration(key, at) {
     // nobody has typed into yet. Before #1930 the same protection came from
     // comparing the event's timestamp against the generation.
     if (turn.closedAt !== null)
-        return;
+        return outcome;
     // An OPEN turn is closed and carried across, so `capture --json` can say
     // `closedBy: 'generation'` rather than going quiet. `getStructuredSessionState`
     // reads that reason as "nothing is known", so it publishes no verdict either
@@ -304,6 +347,7 @@ function fenceTurnForNewGeneration(key, at) {
     turn.closedAt = at;
     turn.closedBy = 'generation';
     turn.generationAt = at;
+    return outcome;
 }
 /**
  * The turn transition: what one delivery does to {@link TurnRecord}
@@ -406,23 +450,32 @@ function applyTurnTransition(key, record) {
     // An event stamped before the current generation was produced by a process
     // that has been replaced. Refusing it here is what makes re-recording a stale
     // `user_prompt_submit` at its original timestamp a no-op.
-    if (generation !== null && record.at < generation)
-        return;
+    if (generation !== null && record.at < generation) {
+        if (record.event === 'stop')
+            return { kind: 'stop-rejected', reason: 'before-generation' };
+        if (record.event === 'session_end')
+            return { kind: 'session-end-rejected', reason: 'before-generation' };
+        return { kind: 'none' };
+    }
     switch (record.event) {
-        case 'user_prompt_submit':
+        case 'user_prompt_submit': {
             // Issue #3330: a queued notice the agent attached to its running turn
             // continues that turn; any other prompt is a new one.
-            openTurn(key, record, generation, { continueOpen: record.joinsOpenTurn === true });
+            const outcome = openTurn(key, record, 'user_prompt_submit', generation, {
+                continueOpen: record.joinsOpenTurn === true,
+            });
             releaseAllDecisions(key);
-            return;
-        case 'post_tool_use':
-            openTurn(key, record, generation, { continueOpen: true });
+            return outcome;
+        }
+        case 'post_tool_use': {
+            const outcome = openTurn(key, record, 'post_tool_use', generation, { continueOpen: true });
             // The tool call the dialog was gating has finished, so somebody answered
             // it (Issue #1726). This is the release #1725 could not have: it had no
             // event meaning "the human answered", only `Stop` meaning "the turn
             // ended", which can be minutes later.
             releaseAllDecisions(key);
-            return;
+            return outcome;
+        }
         case 'pre_tool_use':
             // Deliberately leaves the dialog alone (Issue #1726). It is the
             // `AskUserQuestion` invocation, and a picker being *about to be drawn* is
@@ -432,28 +485,26 @@ function applyTurnTransition(key, record) {
             // start of a turn when the agent's own `Stop` is the last thing that
             // ended one. See the `after its stop` row above.
             if (record.promptOpensTurns === true && endedByOwnStop(key))
-                return;
-            openTurn(key, record, generation, { continueOpen: true });
-            return;
+                return { kind: 'none' };
+            return openTurn(key, record, 'pre_tool_use', generation, { continueOpen: true });
         case 'stop':
-            applyStopToTurn(key, record, generation);
-            return;
-        case 'session_end':
-            applySessionEndToTurn(key, record);
+            return applyStopToTurn(key, record, generation);
+        case 'session_end': {
+            const outcome = applySessionEndToTurn(key, record);
             releaseAllDecisions(key);
-            return;
+            return outcome;
+        }
         case 'session_start':
             // The generation was opened by `recordAgentEvent` before this ran, and
             // `fenceTurnForNewGeneration` closed the turn with it. Nothing further:
             // the frame carries no verdict, so it is not the displayed event either.
-            return;
+            return { kind: 'none' };
         case 'notification':
-            applyNotificationToTurn(key, record, generation);
-            return;
+            return applyNotificationToTurn(key, record, generation);
         default:
             // exhaustive check: a new AgentEventType must decide its transition here
             record.event;
-            return;
+            return { kind: 'none' };
     }
 }
 /**
@@ -494,8 +545,10 @@ function displayOf(record) {
  *   this event's turn. False for `user_prompt_submit`, which IS a new turn —
  *   unless the source marked it as joining the running one (Issue #3330).
  */
-function openTurn(key, record, generation, { continueOpen }) {
+function openTurn(key, record, event, generation, { continueOpen }) {
     const turn = fencedTurn(key);
+    // Issue #3798: read before anything below rewrites the record.
+    const previous = describePrevious(turn, record.sessionId, record.at);
     const openHere = turn !== null &&
         turn.closedAt === null &&
         turn.openedAt !== null &&
@@ -506,7 +559,7 @@ function openTurn(key, record, generation, { continueOpen }) {
         // partway through. Learning it is what lets a later `stop` be matched.
         turn.sessionId ??= record.sessionId;
         turn.scraperCompletionPolls = 0;
-        return;
+        return { kind: 'continued', turnId: turn.turnId };
     }
     // A dialog-only record (openedAt null) is not a turn; its decisions belong to
     // the turn that is opening now, because that is when they were raised.
@@ -532,6 +585,7 @@ function openTurn(key, record, generation, { continueOpen }) {
         exports.reopenedTurns.set(key, { turnId: opened.turnId, replaced: turn });
         (0, agent_event_dedup_1.trimOldestEntries)(exports.reopenedTurns, agent_event_dedup_1.MAX_RECENT_EVENT_KEYS);
     }
+    return { kind: 'opened', turnId: opened.turnId, event, generation: toGenerationRef(generation), previous };
 }
 /**
  * Give a dropped copy's queued-notice mark its effect (Issue #3330).
@@ -590,6 +644,11 @@ function joinOpenTurnFromDuplicate(worktreeId, cliToolId, instanceId, record) {
         scraperCompletionPolls: 0,
     });
     exports.reopenedTurns.delete(key);
+    // Issue #3798: a wait that opened under the discarded turn belongs to the
+    // turn put back. Told through the sink — this runs outside `recordAgentEvent`.
+    globalThis.__agentEventTurnOutcomeSink?.({ worktreeId, cliToolId, instanceId }, [
+        { kind: 'restored', restoredTurnId: replaced.turnId, discardedTurnId: current.turnId },
+    ]);
     return true;
 }
 /**
@@ -604,15 +663,27 @@ function applyStopToTurn(key, record, generation) {
     const turn = fencedTurn(key);
     if (turn !== null && turn.closedAt === null && turn.openedAt !== null) {
         if (!(0, provisional_turn_1.closesTurn)(turn, record.sessionId))
-            return;
+            return { kind: 'stop-rejected', reason: 'other-session' };
         turn.closedAt = record.at;
         turn.closedBy = 'stop';
         turn.displayEvent = displayOf(record);
         releaseAllDecisions(key);
-        return;
+        return { kind: 'stopped', turnId: turn.turnId, generation: toGenerationRef(generation) };
+    }
+    const previous = describePrevious(turn, record.sessionId, record.at);
+    // Issue #3798: a dialog raised by one agent session is not ended by another
+    // session's stop. Both ids are needed to tell — a record or a stop with no id
+    // is read as the same session, as `closesTurn` reads it. opencode publishes
+    // `session.idle` for every session its server holds (#1758 §5.6).
+    if (previous.kind === 'dialog-only' &&
+        previous.sessionId !== null &&
+        record.sessionId !== null &&
+        previous.sessionId !== record.sessionId) {
+        return { kind: 'stop-rejected', reason: 'other-session' };
     }
+    const recordTurnId = nextTurnId(record.at);
     exports.agentTurns.set(key, {
-        turnId: nextTurnId(record.at),
+        turnId: recordTurnId,
         sessionId: record.sessionId,
         openedAt: null,
         closedAt: record.at,
@@ -623,6 +694,7 @@ function applyStopToTurn(key, record, generation) {
         scraperCompletionPolls: 0,
     });
     boundTurnMap();
+    return { kind: 'stop-without-turn', recordTurnId, generation: toGenerationRef(generation), previous };
 }
 /**
  * `session_end`: the agent session this instance was talking to is gone.
@@ -643,11 +715,12 @@ function applyStopToTurn(key, record, generation) {
 function applySessionEndToTurn(key, record) {
     const turn = fencedTurn(key);
     if (turn === null)
-        return;
+        return { kind: 'session-end-rejected', reason: 'no-turn' };
     if (!(0, provisional_turn_1.closesTurn)(turn, record.sessionId))
-        return;
+        return { kind: 'session-end-rejected', reason: 'other-session' };
     turn.closedAt = record.at;
     turn.closedBy = 'session_end';
+    return { kind: 'session-ended', turnId: turn.turnId };
 }
 /**
  * The notification rows of the transition table.
@@ -663,10 +736,9 @@ function applyNotificationToTurn(key, record, generation) {
             // reached the agent. There is no dialog and there never was one for a
             // human to answer — opening a record for it published `waiting` for the
             // whole of the tool call that followed (measured at eight seconds).
-            releaseSettledDecision(key, record);
-            return;
+            return releaseSettledDecision(key, record);
         }
-        openDecision(key, generation, {
+        const opened = openDecision(key, generation, {
             source: 'notification',
             at: record.at,
             message: record.message ?? null,
@@ -679,16 +751,17 @@ function applyNotificationToTurn(key, record, generation) {
             patterns: record.decisionPatterns ?? null,
             decisionId: record.decisionId ?? null,
             bootstrapDisplay: displayOf(record),
+            sessionId: record.sessionId,
         });
-        return;
+        return { kind: 'decision-opened', ...opened };
     }
     if (record.detail === agent_event_types_1.PERMISSION_REPLIED_DETAIL) {
         // Issue #1898. The agent's own statement that the dialog is gone — whoever
         // answered it. Not a word this build reads a status from, so it decides
         // nothing; all it does is retire the record.
         if (record.promptSettled === true)
-            releaseSettledDecision(key, record);
-        return;
+            return releaseSettledDecision(key, record);
+        return { kind: 'none' };
     }
     if (record.detail === 'idle_prompt') {
         // The agent reporting it is sitting at the composer waiting for input is the
@@ -697,10 +770,10 @@ function applyNotificationToTurn(key, record, generation) {
         const turn = fencedTurn(key);
         if (turn !== null && turn.closedAt === null) {
             turn.displayEvent = displayOf(record);
-            return;
+            return { kind: 'none' };
         }
         if (turn !== null)
-            return;
+            return { kind: 'none' };
         // Nothing to attach it to — the first thing this instance ever said, or the
         // first since a generation. It still carries a verdict (`ready`), and #1723
         // publishes it, so a display-only record is opened to hold it. `openedAt`
@@ -718,10 +791,11 @@ function applyNotificationToTurn(key, record, generation) {
             scraperCompletionPolls: 0,
         });
         boundTurnMap();
-        return;
+        return { kind: 'none' };
     }
     // An unrecognised notification type is not evidence of anything, and guessing
     // would be worse than the scraper.
+    return { kind: 'none' };
 }
 /**
  * Open, or refresh, a dialog record on this instance's turn.
@@ -736,7 +810,7 @@ function openDecision(key, generation, input) {
     if (turn === null) {
         turn = {
             turnId: nextTurnId(input.at),
-            sessionId: null,
+            sessionId: input.sessionId ?? null,
             openedAt: null,
             closedAt: null,
             closedBy: null,
@@ -754,7 +828,7 @@ function openDecision(key, generation, input) {
         // late. Re-open a dialog-only record rather than resurrecting the turn.
         turn = {
             turnId: nextTurnId(input.at),
-            sessionId: null,
+            sessionId: input.sessionId ?? null,
             openedAt: null,
             closedAt: null,
             closedBy: null,
@@ -766,6 +840,15 @@ function openDecision(key, generation, input) {
         exports.agentTurns.set(key, turn);
         boundTurnMap();
     }
+    else if (turn.openedAt === null && turn.sessionId === null) {
+        // A dialog-only record bootstrapped by a forecast with no session learns
+        // the session from the report that confirms it.
+        turn.sessionId = input.sessionId ?? null;
+    }
+    const opened = {
+        recordTurnId: turn.turnId,
+        recordKind: turn.openedAt !== null ? 'turn' : 'dialog-only',
+    };
     // Issue #1930 / S1: an id that fails validation is DISCARDED, not truncated —
     // a truncated id compares equal to a different id sharing its prefix, and the
     // reply to one approval would then retire another's record.
@@ -807,14 +890,14 @@ function openDecision(key, generation, input) {
             existing.source = 'notification';
             existing.confirmedAt ??= input.at;
         }
-        return;
+        return opened;
     }
     if (turn.pendingDecisions.length >= provisional_turn_1.MAX_PENDING_DECISIONS_PER_TURN) {
         // S14(d). Counted rather than dropped in silence: an agent raising more
         // approvals than this in one turn is a fact an operator has to be able to
         // see, and the oldest is the one a human has been looking at.
         (0, agent_event_dedup_1.dropsFor)(key).decisionOverflow += 1;
-        return;
+        return opened;
     }
     turn.pendingDecisions.push({
         decisionId,
@@ -827,6 +910,7 @@ function openDecision(key, generation, input) {
         scraperCorroborated: false,
         recorded: false,
     });
+    return opened;
 }
 /** Retire every dialog this instance was holding. */
 function releaseAllDecisions(key) {
@@ -846,15 +930,25 @@ function releaseAllDecisions(key) {
 function releaseSettledDecision(key, record) {
     const turn = fencedTurn(key);
     if (turn === null || turn.pendingDecisions.length === 0)
-        return;
+        return { kind: 'none' };
+    const before = turn.pendingDecisions.length;
     const settledId = record.decisionId === null || record.decisionId === undefined
         ? null
         : (0, provisional_turn_1.acceptExternalId)(record.decisionId);
     if (settledId === null) {
         turn.pendingDecisions = [];
-        return;
     }
-    turn.pendingDecisions = turn.pendingDecisions.filter((decision) => decision.decisionId !== null && decision.decisionId !== settledId);
+    else {
+        turn.pendingDecisions = turn.pendingDecisions.filter((decision) => decision.decisionId !== null && decision.decisionId !== settledId);
+    }
+    // Issue #3798: an explicit answer — the one release that ends a wait.
+    return {
+        kind: 'decision-answered',
+        recordTurnId: turn.turnId,
+        recordKind: turn.openedAt !== null ? 'turn' : 'dialog-only',
+        before,
+        remaining: turn.pendingDecisions.length,
+    };
 }
 /** Keep the turn map bounded the way every other map in this module is. */
 function boundTurnMap() {

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

@@ -35,6 +35,14 @@ const session_status_options_1 = require("../../lib/tmux/session-status-options"
 const tmux_1 = require("../../lib/tmux/tmux");
 const tmux_session_surface_1 = require("./tmux-session-surface");
 const logger = (0, logger_1.createLogger)('cli-session');
+/** Tell the observer this capture runs for, if any, where its frame came from (Issue #3798). */
+function reportFrameMeta(meta) {
+    globalThis.__captureFrameMetaSink?.getStore()?.(meta);
+}
+/** Tell the observer this capture runs for, if any, whether its window cut the pane's top (Issue #3881 N4). */
+function reportHeadCut(headCut) {
+    globalThis.__captureHeadCutSink?.getStore()?.(headCut);
+}
 function getDefaultTransport() {
     return (0, polling_tmux_transport_1.getPollingTmuxTransport)();
 }
@@ -95,7 +103,11 @@ async function captureSessionOutput(worktreeId, cliToolId, lines = 1000, instanc
                 throw new Error(`${cliTool.name} session ${sessionName} does not exist`);
             }
             return await transport.captureSnapshot(sessionName, { startLine: -tmux_capture_cache_1.CACHE_MAX_CAPTURE_LINES });
-        });
+        }, 
+        // Issue #3798: this call's own frame, to the observer it runs for
+        reportFrameMeta, 
+        // Issue #3881 (third review N4): and whether the window cut its top
+        reportHeadCut);
         log.debug('captureSessionOutput:success', {
             actualLines: output.split('\n').length,
             lastFewLines: output.split('\n').slice(-3).join(' | '),
@@ -132,18 +144,25 @@ async function captureSessionOutputFresh(worktreeId, cliToolId, lines = 5000, in
     const transport = getDefaultTransport();
     // Issue #3734: snapshot the generation before the capture starts
     const generation = (0, tmux_capture_cache_1.getCaptureGeneration)(sessionName);
+    // Issue #3798: and the time, so the cache says when this frame was fetched,
+    // not when a slow capture came back
+    const fetchStartedAt = Date.now();
     try {
         const output = await transport.captureSnapshot(sessionName, { startLine: -lines });
         // 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) {
             if ((0, tmux_capture_cache_1.isCaptureGenerationCurrent)(sessionName, generation)) {
-                (0, tmux_capture_cache_1.setCachedCapture)(sessionName, output, lines);
+                (0, tmux_capture_cache_1.setCachedCapture)(sessionName, output, lines, fetchStartedAt);
             }
         }
         else {
             (0, tmux_capture_cache_1.invalidateCache)(sessionName);
         }
+        reportFrameMeta({ fetchStartedAt, source: 'fetched' });
+        const headCutSink = globalThis.__captureHeadCutSink?.getStore();
+        if (headCutSink)
+            headCutSink((0, tmux_capture_cache_1.sliceCutsHead)(output, lines));
         return (0, tmux_capture_cache_1.sliceOutput)(output, lines);
     }
     catch (error) {

package/dist/server/src/lib/session/current-output-builder.js

@@ -33,7 +33,11 @@ const cli_session_1 = require("../../lib/session/cli-session");
 const status_detector_1 = require("../../lib/detection/status-detector");
 const auto_yes_manager_1 = require("../../lib/polling/auto-yes-manager");
 const auto_yes_suppression_state_1 = require("../../lib/polling/auto-yes-suppression-state");
-const auto_yes_enter_fallback_1 = require("../../lib/polling/auto-yes-enter-fallback");
+const auto_yes_poller_state_1 = require("../../lib/polling/auto-yes-poller-state");
+const waiting_episode_state_1 = require("../../lib/session/waiting-episode-state");
+const auto_yes_state_1 = require("../../lib/auto-yes-state");
+const auto_yes_decision_state_1 = require("../../lib/polling/auto-yes-decision-state");
+const antigravity_receipt_episodes_1 = require("../../lib/polling/antigravity-receipt-episodes");
 const prompt_dedup_state_1 = require("../../lib/polling/prompt-dedup-state");
 const status_capture_config_1 = require("../../config/status-capture-config");
 const tmux_capture_cache_1 = require("../../lib/tmux/tmux-capture-cache");
@@ -45,6 +49,7 @@ const status_evidence_1 = require("../../lib/session/status-evidence");
 const ask_user_question_prompt_1 = require("../../lib/session/ask-user-question-prompt");
 const prompt_view_1 = require("../../lib/session/prompt-view");
 const auto_yes_dialog_gate_1 = require("../../lib/polling/auto-yes-dialog-gate");
+const prompt_screen_reading_1 = require("../../lib/polling/prompt-screen-reading");
 const layer_disagreement_1 = require("../../lib/session/layer-disagreement");
 const structured_prompt_1 = require("../../lib/session/structured-prompt");
 const chat_turn_progress_1 = require("./chat-turn-progress");
@@ -226,7 +231,7 @@ function readAgentEvents(worktreeId, cliToolId, instanceId, resolvedInstanceId)
  * every value below is derived from the arguments, and nothing is assigned
  * outside this function.
  */
-function composePromptData({ worktreeId, cliToolId, output, statusResult, startingSince, promptWaiting, askUserQuestion, eventSource, }) {
+function composePromptData({ worktreeId, cliToolId, output, captureWindowLines, statusResult, startingSince, promptWaiting, askUserQuestion, eventSource, }) {
     const scraperPromptWaiting = statusResult.hasActivePrompt;
     // Issue #1726: the agent's own account of what it asked. It contributes only
     // where some other layer has already established that a dialog is on screen —
@@ -238,7 +243,14 @@ function composePromptData({ worktreeId, cliToolId, output, statusResult, starti
     // takes it there today (the decision entries publish the same episode's
     // choices) — and this line now re-uses it, so the two surfaces cannot describe
     // different instants.
-    const scraperPromptData = statusResult.promptDetection.promptData;
+    //
+    // Issue #3881 (second review N3): with the capture's top as the Auto-Yes
+    // poller reads it — an approval target whose upward scan reached a top that
+    // may be cut carries `approvalTargetCompleteness: 'top-unknown'`, so the
+    // contract re-evaluation of `observe=1` (`prompt-observation/observe.ts`)
+    // and `wait` read the same completeness the poller acted on, from the same
+    // `captureTopOf` on this payload's own capture window.
+    const scraperPromptData = (0, prompt_screen_reading_1.withCaptureTopCompleteness)(statusResult.promptDetection, (0, prompt_screen_reading_1.captureTopOf)(output, captureWindowLines, cliToolId)).promptData;
     const correctedPromptData = scraperPromptData && askUserQuestion
         ? (0, ask_user_question_prompt_1.applyAskUserQuestion)(scraperPromptData, askUserQuestion.spec)
         : null;
@@ -468,12 +480,26 @@ function logDetectionDivergence(worktreeId, cliToolId, resolvedInstanceId, statu
         });
     }
 }
+/**
+ * Issue #3821: the agy hook call the receipt on screen was accepted for, for
+ * the decision to be matched against; null when unknown. Read only, never throws.
+ */
+function acceptedAgyCallId(worktreeId, instanceId) {
+    try {
+        return (0, antigravity_receipt_episodes_1.getAntigravityAcceptedReceiptCallId)(worktreeId, instanceId);
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * The payload of a running session (Issue #3272). Split out of
  * {@link buildPayload} as it stood there, so the keys keep their order and the
  * reads inside it keep theirs.
  */
-function buildRunningPayload({ worktreeId, cliToolId, instanceId, sessionName, published, merged, newContent, output, realtimeSnippet, totalLines, lastCapturedLine, isPromptWaiting, promptData, promptAnswerable, autoYesState, lastEnterFallback, isSelectionListActive, isPagerActive, isDismissablePanelActive, startingSince, lastKnown, lastServerResponseTimestamp, compositeKey, stopEventAt, structuredEvents, model, effort, upstreamFaultMatch, paneObstruction, composer, }) {
+function buildRunningPayload({ worktreeId, cliToolId, instanceId, sessionName, published, merged, newContent, output, realtimeSnippet, totalLines, lastCapturedLine, isPromptWaiting, promptData, promptAnswerable, autoYesState, lastEnterFallback, autoYesDecision, isSelectionListActive, isPagerActive, isDismissablePanelActive, startingSince, lastKnown, lastServerResponseTimestamp, compositeKey, stopEventAt, structuredEvents, model, effort, upstreamFaultMatch, paneObstruction, composer, }) {
+    const lastSuppression = (0, auto_yes_suppression_state_1.getLastPolicySuppression)(worktreeId, cliToolId, instanceId);
+    const waitingEpisodeId = (0, waiting_episode_state_1.getWaitingEpisodeRecord)(worktreeId, cliToolId, instanceId)?.episodeId ?? null;
     return {
         isRunning: true,
         sessionName,
@@ -496,14 +522,29 @@ function buildRunningPayload({ worktreeId, cliToolId, instanceId, sessionName, p
             enabled: autoYesState?.enabled ?? false,
             expiresAt: autoYesState?.enabled ? autoYesState.expiresAt : null,
             stopReason: autoYesState?.stopReason,
-            lastSuppression: (0, auto_yes_suppression_state_1.getLastPolicySuppression)(worktreeId, cliToolId, instanceId),
+            lastSuppression,
+            // Issue #3798: read in the same step as the record above, which names the
+            // wait it was written for — `cmate wait` holds the two against each other.
+            waitingEpisodeId,
             // Issue #1694: undefined (so the key is absent from the JSON) unless a
             // stop pattern actually fired — the state clears it on every other path.
             stopMatchedText: autoYesState?.stopMatchedText,
             // Issue #3397: appended last, after the published fields above. Null when
-            // Auto-Yes never sent its Enter to an unreadable choice screen here.
+            // Auto-Yes never sent its Enter to an unreadable choice screen here —
+            // always, since Issue #3821 retired the Enter.
             lastEnterFallback,
+            // Issue #3798: appended last. Whether the poller answered the open wait
+            // after the record above was written — the push gate's own reading, so
+            // `cmate wait` does not take that record for this wait's reason.
+            lastSuppressionAnswered: lastSuppression !== null &&
+                (0, auto_yes_suppression_state_1.suppressionPredatesAnswer)(lastSuppression, waitingEpisodeId, (0, auto_yes_poller_state_1.getAutoYesLastAnswer)(compositeKey)),
         },
+        // Issue #3821: next to `autoYes`, and about `promptData` above — whether
+        // Auto-Yes is answering it, has left it to a human, or neither.
+        autoYesDecision,
+        // Issue #3863: how a question on this screen is treated while Auto-Yes is
+        // on; the key is absent while it is off.
+        ...(autoYesState?.enabled ? { autoYesAnswerMode: (0, auto_yes_state_1.autoYesAnswerModeOf)(autoYesState) } : {}),
         isSelectionListActive,
         isPagerActive,
         isDismissablePanelActive,
@@ -664,7 +705,8 @@ async function buildPayload(db, worktreeId, cliToolId, instanceId) {
     // The effective window is the smaller of what this path asks for and what the
     // capture layer will ever fetch — captureSessionOutput() reads at most
     // CACHE_MAX_CAPTURE_LINES regardless of the request.
-    const captureWindowSaturated = (0, tmux_capture_cache_1.isCaptureWindowSaturated)(totalLines, Math.min(status_capture_config_1.STATUS_CAPTURE_LINES, tmux_capture_cache_1.CACHE_MAX_CAPTURE_LINES));
+    const captureWindowLines = Math.min(status_capture_config_1.STATUS_CAPTURE_LINES, tmux_capture_cache_1.CACHE_MAX_CAPTURE_LINES);
+    const captureWindowSaturated = (0, tmux_capture_cache_1.isCaptureWindowSaturated)(totalLines, captureWindowLines);
     // Issue #1910: saturation of the capture WINDOW is only one of the two ways
     // the cursor dies, and it is the one that never fires for the alternate-screen
     // tools — their pane is 1000 rows (claude / copilot) or 200 (opencode), so a
@@ -761,6 +803,7 @@ async function buildPayload(db, worktreeId, cliToolId, instanceId) {
         worktreeId,
         cliToolId,
         output,
+        captureWindowLines,
         statusResult,
         startingSince,
         promptWaiting,
@@ -922,10 +965,20 @@ async function buildPayload(db, worktreeId, cliToolId, instanceId) {
         promptData,
         promptAnswerable,
         autoYesState,
-        // Issue #3397: judged against the screen-read prompt only — the one
-        // `promptAnswerable` is published for, and the one the poller sent its
-        // Enter to. A structured (hook / degraded) prompt is never that screen.
-        lastEnterFallback: (0, auto_yes_enter_fallback_1.publishEnterFallback)((0, auto_yes_enter_fallback_1.getLastEnterFallback)(worktreeId, cliToolId, instanceId), promptAnswerable !== undefined ? statusResult.promptDetection.promptData : null),
+        // Issue #3821: the Enter is retired; the key is kept, and is null.
+        lastEnterFallback: null,
+        // Issue #3821: judged against the screen-read prompt only — the one
+        // `promptAnswerable` is published for, and the only kind the poller
+        // answers. A structured (hook / degraded) prompt is never that screen, and
+        // reads `none`.
+        autoYesDecision: (0, auto_yes_decision_state_1.publishAutoYesDecision)({
+            compositeKey,
+            grant: autoYesState,
+            promptData: promptData !== null && promptAnswerable !== undefined ? statusResult.promptDetection.promptData : null,
+            // agy: the decision is tied to the hook call its receipt was accepted for.
+            callId: cliToolId === 'antigravity' ? acceptedAgyCallId(worktreeId, instanceId) : null,
+            pollerActive: (0, auto_yes_manager_1.isPollerActive)(compositeKey),
+        }),
         isSelectionListActive,
         isPagerActive,
         isDismissablePanelActive,

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

@@ -82,6 +82,12 @@ function getLastSendAttempt(instance) {
 function clearSendAttempts() {
     records.clear();
 }
+/**
+ * The wordings of a failed tmux call that can carry the message body: `tmux.ts`
+ * wraps the child_process error (`Command failed: tmux …argv…`) as
+ * `Failed to send keys to tmux session: …` and the like (Issue #3880).
+ */
+const TMUX_TRANSPORT_FAILURE = /Command failed: tmux |Failed to send (?:special )?keys? to tmux session|Failed to send special key:|Failed to paste message into tmux session/;
 /**
  * Where a failed `ICLITool.sendMessage` stopped, read from its error.
  *
@@ -103,13 +109,10 @@ function classifySendFailure(error) {
         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' };
-    }
+    // Issue #3880: the "after the body was typed" wordings are matched FIRST. A
+    // body-not-landed error quotes what the composer shows — the user's own text —
+    // and a body that says `prompt not ready` must not turn "may have been typed"
+    // into "was not typed". Indeterminate wins whenever its wording is present.
     // #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' };
@@ -122,6 +125,19 @@ function classifySendFailure(error) {
     if (/submit could not be confirmed/i.test(message)) {
         return { state: 'indeterminate', reason: 'submit-unconfirmed' };
     }
+    // Issue #3880 (N2): a failed tmux call quotes its argv — and the argv of a
+    // literal send IS the body (`Command failed: tmux send-keys -t =s: -l -- <body>`).
+    // Whether any of the body reached the pane is unknown, and the body's own words
+    // (`Explain prompt not ready.`) must not be read as a readiness refusal below.
+    if (TMUX_TRANSPORT_FAILURE.test(message))
+        return { state: 'indeterminate', reason: 'send-error' };
+    // The readiness waits of every tool throw before typing anything.
+    if (/prompt not ready/i.test(message))
+        return { state: 'not-sent', reason: 'prompt-not-ready' };
+    // #1880: refused before the body, after only the clear keys (C-e / C-u).
+    if (/still holds unsent text after \d+ clear passes/.test(message)) {
+        return { state: 'not-sent', reason: 'composer-not-empty' };
+    }
     return { state: 'indeterminate', reason: 'send-error' };
 }
 /** The whitespace-free form two renderings of one text share. */