commandmate 0.47.2 → 0.49.0

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,
@@ -871,7 +914,8 @@ async function buildPayload(db, worktreeId, cliToolId, instanceId) {
     // Issue #1879: structural, and computed here next to the other frame readers
     // rather than inside a status branch — the bar it feeds must appear on the
     // strength of what is in the box, never on the strength of a status verdict.
-    const composer = (0, composer_text_1.extractComposerText)(output, cliToolId);
+    // Issue #3927: the live box — a codex composer left above a dialog is not one.
+    const composer = (0, composer_text_1.extractLiveComposerText)(output, cliToolId);
     // Issue #1839: judged on exactly what is published as `realtimeSnippet`, not
     // on `output`. The wider capture keeps a banner from an hour ago in scope, and
     // a fault the operator cannot see in the payload next to it is unverifiable.
@@ -922,10 +966,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,20 @@ 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, or C-e / BSpace
+    // for a codex composer holding only a paste placeholder, #3937).
+    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. */

package/dist/server/src/lib/session/waiting-episode-binding-observation.js

@@ -0,0 +1,289 @@
+"use strict";
+/**
+ * The observation half of `waiting-episode-binding` (Issue #3798): the
+ * observers' starts, the dating of a captured frame, and the plan of tables
+ * O-1 / O-2. Split out of `waiting-episode-binding` (Issue #3892), which
+ * re-exports all of it and carries the plan out (`commitWaitingObservation`).
+ *
+ * @module lib/session/waiting-episode-binding-observation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startWaitingObservation = startWaitingObservation;
+exports.startWorktreeWaitingObservations = startWorktreeWaitingObservations;
+exports.captureFrameTime = captureFrameTime;
+exports.captureObservedFrame = captureObservedFrame;
+exports.planWaitingObservation = planWaitingObservation;
+const async_hooks_1 = require("async_hooks");
+const auto_yes_state_1 = require("../../lib/auto-yes-state");
+const prompt_screen_key_1 = require("../../lib/detection/prompt-screen-key");
+const agent_event_turn_1 = require("../../lib/session/agent-event-turn");
+const waiting_episode_binding_resolve_1 = require("../../lib/session/waiting-episode-binding-resolve");
+const waiting_episode_state_1 = require("../../lib/session/waiting-episode-state");
+const waiting_episode_verdict_1 = require("../../lib/session/waiting-episode-verdict");
+const global_state_1 = require("../global-state");
+/** Where `cli-session` reports a frame's source to the observer it runs for (Issue #3798). */
+function frameMetaSink() {
+    return (0, global_state_1.getOrInitGlobal)('__captureFrameMetaSink', () => new async_hooks_1.AsyncLocalStorage());
+}
+/** Fix the observer's start (design §2.5). Read-only. */
+function startWaitingObservation(worktreeId, cliToolId, instanceId) {
+    return {
+        generation: (0, waiting_episode_binding_resolve_1.generationOf)({ worktreeId, cliToolId, instanceId }),
+        version: (0, waiting_episode_state_1.getEpisodeVersion)(worktreeId, cliToolId, instanceId),
+    };
+}
+/**
+ * Fix the start of every instance of a worktree at once (design §2.5): the
+ * status routes call it before `listSessions()`, so a session that started —
+ * and opened a wait — after the list was taken is not closed as gone by a
+ * probe that did not see it. Instances that have no version or generation yet
+ * are fixed at 0 / none.
+ */
+function startWorktreeWaitingObservations(worktreeId) {
+    const prefix = `${worktreeId}${auto_yes_state_1.COMPOSITE_KEY_SEPARATOR}`;
+    const versions = (0, waiting_episode_state_1.snapshotEpisodeVersions)(worktreeId);
+    const generations = new Map();
+    for (const [key, at] of agent_event_turn_1.generationStartedAt) {
+        if (key.startsWith(prefix))
+            generations.set(key, at);
+    }
+    return {
+        startFor(cliToolId, instanceId) {
+            const key = (0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId);
+            return { generation: (0, agent_event_turn_1.toGenerationRef)(generations.get(key) ?? null), version: versions.get(key) ?? 0 };
+        },
+    };
+}
+/**
+ * When the frame a scraper just read was fetched (design §2.2
+ * `frameCapturedAt`), from `meta` — what the capture reported for that one
+ * frame ({@link captureObservedFrame}). A frame served from the cache, or
+ * joined to a fetch already in flight, is as old as that fetch, and is never
+ * one this observer fetched itself — even when that fetch started in the very
+ * millisecond the observer asked. Only a frame the capture fetched itself,
+ * starting at or after `requestedAt` (the moment the observer asked, after its
+ * start), counts as fetched after the start. A frame nothing was reported for
+ * (a capture module a test replaced) is dated 0, before any close (design
+ * §2.6): it opens no wait I6 would hold back, and closes no `screen`.
+ */
+function captureFrameTime(meta, requestedAt) {
+    if (meta === null)
+        return { frameCapturedAt: 0, frameFetchedAfterStart: false };
+    return {
+        frameCapturedAt: Math.min(meta.fetchStartedAt, requestedAt),
+        frameFetchedAfterStart: meta.source === 'fetched' && meta.fetchStartedAt >= requestedAt,
+    };
+}
+/**
+ * Run one capture for an observer and date the frame it returns (Issue #3798):
+ * `cli-session` reports where THIS call's frame came from through an async
+ * context set up here, so another capture of the same session running at the
+ * same time — a different number of lines, a different text — cannot stand in
+ * for it.
+ */
+async function captureObservedFrame(capture) {
+    const reported = { meta: null };
+    const requestedAt = Date.now();
+    const frame = await frameMetaSink().run((meta) => {
+        reported.meta = meta;
+    }, capture);
+    return { frame, frameTime: captureFrameTime(reported.meta, requestedAt) };
+}
+function screenBinding(generation, originTurnId) {
+    return { kind: 'screen', generation, originTurnId };
+}
+function sameBinding(a, b) {
+    if (a.kind !== b.kind)
+        return false;
+    switch (a.kind) {
+        case 'turn':
+            return a.turnId === b.turnId;
+        case 'dialog-only':
+            return a.recordTurnId === b.recordTurnId;
+        default:
+            return true;
+    }
+}
+/** Whether the Auto-Yes poller answered this episode and the screen now shows another confirmation (R1-7, PR 3). */
+function answeredThenAnother(obs, episode, k) {
+    return (obs.freshPrompt === true &&
+        obs.lastAnswer != null &&
+        obs.lastAnswer.episodeId === episode.episodeId &&
+        k !== null &&
+        k !== obs.lastAnswer.screenKey);
+}
+/** Table O-1: a `waiting` reading on the instance's episode (or none). */
+function verdictForWaiting(obs, episode, humanHeld, c, k, current) {
+    if (episode === null)
+        return { action: 'opened', binding: c };
+    const binding = episode.binding;
+    // The row below the table: a binding of another generation is replaced (P3-2).
+    if (!(0, waiting_episode_verdict_1.sameGeneration)(binding.generation, current))
+        return { action: 'replaced', binding: c };
+    if (humanHeld) {
+        if (binding.kind === 'screen')
+            return { action: 'kept' };
+        return { action: 'rebound', binding: screenBinding(current, binding.kind === 'turn' ? binding.turnId : null) };
+    }
+    switch (binding.kind) {
+        case 'turn': {
+            const stillOpen = c.kind === 'turn' && c.turnId === binding.turnId;
+            if (stillOpen)
+                return answeredThenAnother(obs, episode, k) ? { action: 'replaced', binding: c } : { action: 'kept' };
+            if (c.kind === 'turn')
+                return { action: 'replaced', binding: c };
+            // T has ended (stop, screen evidence, the 30-minute stale bound — R2-3):
+            // only another confirmation replaces it.
+            return obs.freshPrompt === true && k !== null && k !== episode.promptScreenKey
+                ? { action: 'replaced', binding: c }
+                : { action: 'kept' };
+        }
+        case 'dialog-only':
+            if (c.kind === 'turn')
+                return { action: 'rebound', binding: c };
+            if (c.kind === 'dialog-only' && c.recordTurnId !== binding.recordTurnId)
+                return { action: 'replaced', binding: c };
+            return { action: 'kept' };
+        case 'unattributed':
+            if (c.kind === 'unattributed') {
+                return answeredThenAnother(obs, episode, k) ? { action: 'replaced', binding: c } : { action: 'kept' };
+            }
+            if (c.kind === 'dialog-only')
+                return { action: 'rebound', binding: c };
+            // c = turn(N): the wait turned out to be N's when it shows the same confirmation (R2-4).
+            return k !== null && k === episode.promptScreenKey
+                ? { action: 'rebound', binding: c }
+                : { action: 'replaced', binding: c };
+        case 'screen':
+            return c.kind === 'turn' && c.turnId === binding.originTurnId
+                ? { action: 'rebound', binding: c }
+                : { action: 'replaced', binding: c };
+        default:
+            binding;
+            return { action: 'kept' };
+    }
+}
+/** Table O-2: the closing side. Null when the reading closes nothing. */
+function closeReasonFor(obs, episode) {
+    const { reading } = obs;
+    if (reading.kind === 'gone')
+        return 'session-gone';
+    if (reading.kind !== 'not-waiting')
+        return null;
+    switch (obs.observer) {
+        case 'status-probe':
+            return 'screen-cleared';
+        case 'response-checker':
+            return 'response-recorded';
+        case 'auto-yes-poller':
+            // A screen only after a frame fetched since it became one (R3-1, P3-1);
+            // any other wait only when the poller answered it (PR 3, 規則 3).
+            if (episode.binding.kind === 'screen') {
+                return obs.frameCapturedAt > Math.max(episode.openedAt, episode.boundAt) ? 'screen-cleared' : null;
+            }
+            return obs.lastAnswer != null && obs.lastAnswer.episodeId === episode.episodeId ? 'poller-answered' : null;
+        default:
+            obs.observer;
+            return null;
+    }
+}
+/** Why the old episode of a replacement ended. */
+function replacedBecause(old, next, current) {
+    if (!(0, waiting_episode_verdict_1.sameGeneration)(old.generation, current))
+        return 'generation';
+    return next.kind === 'turn' || next.kind === 'dialog-only' ? 'turn-superseded' : 'screen-cleared';
+}
+/**
+ * Decide what one observation does to the instance's episode (design §2.4
+ * 規則 3・4・5, tables O-1 / O-2 and preconditions 1–3). Reads the store and
+ * the turn model; writes nothing.
+ */
+function planWaitingObservation(obs) {
+    const at = obs.now ?? Date.now();
+    const parts = { worktreeId: obs.worktreeId, cliToolId: obs.cliToolId, instanceId: obs.instanceId };
+    const episode = (0, waiting_episode_state_1.getWaitingEpisodeRecord)(obs.worktreeId, obs.cliToolId, obs.instanceId);
+    const current = (0, waiting_episode_binding_resolve_1.generationOf)(parts);
+    const base = {
+        observation: obs,
+        action: 'ignored',
+        episodeId: episode?.episodeId ?? null,
+        since: obs.reading.kind === 'waiting' ? episode?.since ?? null : null,
+        next: null,
+        binding: null,
+        closeReason: null,
+        ignoredBecause: null,
+        at,
+    };
+    const ignored = (because) => ({
+        ...base,
+        action: 'ignored',
+        ignoredBecause: because,
+    });
+    // Precondition 1: the observer started in another generation.
+    if (!(0, waiting_episode_verdict_1.sameGeneration)(obs.start.generation, current))
+        return ignored('generation');
+    const versionMoved = obs.start.version !== (0, waiting_episode_state_1.getEpisodeVersion)(obs.worktreeId, obs.cliToolId, obs.instanceId) && obs.freshPrompt !== true;
+    const { reading } = obs;
+    if (reading.kind !== 'waiting') {
+        // Table O-2.
+        if (episode === null)
+            return ignored('nothing-open');
+        if (reading.kind === 'unknown')
+            return ignored('unknown-frame');
+        const reason = closeReasonFor(obs, episode);
+        if (reason === null)
+            return ignored('not-this-observer');
+        if (versionMoved)
+            return ignored('version');
+        return { ...base, action: 'closed', closeReason: reason, since: null };
+    }
+    // Table O-1.
+    const k = reading.promptData !== null ? (0, prompt_screen_key_1.promptScreenKey)(reading.promptData) : null;
+    // 規則 1: a person's screen is `screen` whatever the turn model says, with
+    // the open turn as its origin.
+    const resolved = (0, waiting_episode_binding_resolve_1.resolveEpisodeBinding)(parts, at);
+    const c = reading.humanHeld
+        ? screenBinding(current, resolved.kind === 'turn' ? resolved.turnId : null)
+        : resolved;
+    const verdict = verdictForWaiting(obs, episode, reading.humanHeld, c, k, current);
+    if (verdict.action === 'kept')
+        return { ...base, action: 'kept' };
+    // Precondition 2 (I5 (b) / (d)) and 3 (I6).
+    if (versionMoved)
+        return ignored('version');
+    const lastClosed = (0, waiting_episode_state_1.getLastClosedEpisode)(obs.worktreeId, obs.cliToolId, obs.instanceId);
+    const closedBeforeOwnFetch = obs.frameFetchedAfterStart === true &&
+        obs.start.version === (0, waiting_episode_state_1.getEpisodeVersion)(obs.worktreeId, obs.cliToolId, obs.instanceId);
+    if (lastClosed !== null &&
+        !closedBeforeOwnFetch &&
+        obs.frameCapturedAt <= lastClosed.at &&
+        (k === null || k === lastClosed.promptScreenKey)) {
+        return ignored('stale-frame');
+    }
+    if (verdict.action === 'rebound') {
+        if (episode !== null && sameBinding(episode.binding, verdict.binding))
+            return { ...base, action: 'kept' };
+        return { ...base, action: 'rebound', binding: verdict.binding };
+    }
+    const binding = verdict.binding;
+    const structuredSince = reading.structuredSince;
+    const since = verdict.action === 'opened' || episode === null
+        ? structuredSince ?? at
+        : structuredSince !== null && structuredSince > episode.since
+            ? structuredSince
+            : at;
+    const next = {
+        since,
+        kind: reading.waitingKind,
+        binding,
+        openedBy: obs.observer,
+        promptScreenKey: k,
+    };
+    return {
+        ...base,
+        action: verdict.action,
+        since,
+        next,
+        closeReason: verdict.action === 'replaced' && episode !== null ? replacedBecause(episode.binding, binding, current) : null,
+    };
+}

package/dist/server/src/lib/session/waiting-episode-binding-resolve.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * What a new waiting episode is bound to, read from the turn model (Issue #3798).
+ * Split out of `waiting-episode-binding` (Issue #3892), which re-exports it.
+ *
+ * @module lib/session/waiting-episode-binding-resolve
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generationOf = generationOf;
+exports.resolveEpisodeBinding = resolveEpisodeBinding;
+const auto_yes_state_1 = require("../../lib/auto-yes-state");
+const agent_event_turn_1 = require("../../lib/session/agent-event-turn");
+function generationOf(parts) {
+    return (0, agent_event_turn_1.toGenerationRef)((0, agent_event_turn_1.currentGeneration)((0, auto_yes_state_1.buildCompositeKey)(parts.worktreeId, parts.cliToolId, parts.instanceId)));
+}
+/**
+ * What an episode opening now is bound to (design §2.4 規則 1).
+ *
+ * Read from the fenced, aged turn record — the same reading `getAgentTurn`
+ * gives every other reader — with the live decisions counted without retiring
+ * the expired ones, so deciding a binding writes nothing a transition would
+ * later read differently.
+ */
+function resolveEpisodeBinding(parts, at) {
+    const generation = generationOf(parts);
+    const turn = (0, agent_event_turn_1.getAgentTurn)(parts.worktreeId, parts.cliToolId, parts.instanceId, at);
+    if (turn === null)
+        return { kind: 'unattributed', generation, lastClosedTurnId: null };
+    if (turn.closedAt === null && turn.openedAt !== null) {
+        return { kind: 'turn', generation, turnId: turn.turnId };
+    }
+    if (turn.closedAt === null && (0, agent_event_turn_1.liveDecisionCount)(turn, at) > 0) {
+        return { kind: 'dialog-only', generation, recordTurnId: turn.turnId, sessionId: turn.sessionId };
+    }
+    // A closed turn, or a record holding no live decision (an `idle_prompt`
+    // display record, or a forecast whose 20 s ran out).
+    return { kind: 'unattributed', generation, lastClosedTurnId: turn.turnId };
+}