commandmate 0.23.0 → 0.24.0

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

@@ -43,7 +43,14 @@ exports.STRUCTURED_PROMPT_PROVISIONAL_MAX_AGE_MS = exports.STRUCTURED_STATE_MAX_
 exports.recordAgentStopEvent = recordAgentStopEvent;
 exports.getLastStopEventAt = getLastStopEventAt;
 exports.recordAgentEvent = recordAgentEvent;
+exports.getAwaitingInstruction = getAwaitingInstruction;
+exports.isAwaitingInstruction = isAwaitingInstruction;
 exports.getLastAgentEvent = getLastAgentEvent;
+exports.getLastKnownAgentModel = getLastKnownAgentModel;
+exports.recordCapturedModelInfo = recordCapturedModelInfo;
+exports.getLastCapturedModelInfo = getLastCapturedModelInfo;
+exports.getResolvedAgentModelInfo = getResolvedAgentModelInfo;
+exports.getLastKnownAgentEffort = getLastKnownAgentEffort;
 exports.beginAgentEventGeneration = beginAgentEventGeneration;
 exports.getAgentEventGenerationStartedAt = getAgentEventGenerationStartedAt;
 exports.discardAgentEventState = discardAgentEventState;
@@ -60,7 +67,10 @@ exports.isDuplicateAgentEvent = isDuplicateAgentEvent;
 exports.getRecentEventKeyCount = getRecentEventKeyCount;
 exports.clearAgentStopEvents = clearAgentStopEvents;
 const auto_yes_state_1 = require("../../lib/auto-yes-state");
+const agent_event_types_1 = require("../../lib/hooks/agent-event-types");
 const permission_request_payload_1 = require("../../lib/hooks/permission-request-payload");
+// Issue #1784: the terminal-frame half of "which model / effort is this on".
+const model_info_extractor_1 = require("../../lib/detection/model-info-extractor");
 const status_mapping_1 = require("../../lib/session/status-mapping");
 const structured_prompt_1 = require("../../lib/session/structured-prompt");
 /** compositeKey -> epoch ms of the most recent stop event. */
@@ -81,6 +91,46 @@ const askUserQuestion = globalThis.__agentEventAskUserQuestion ??
 /** dedup key -> epoch ms it was first seen. See {@link isDuplicateAgentEvent}. */
 const recentEventKeys = globalThis.__agentEventRecentKeys ??
     (globalThis.__agentEventRecentKeys = new Map());
+/** compositeKey -> the agent's own "I am waiting for instructions" (#1786). */
+const awaitingInstruction = globalThis.__agentEventAwaitingInstruction ??
+    (globalThis.__agentEventAwaitingInstruction = new Map());
+/**
+ * compositeKey -> the last non-null model this instance reported (Issue #1783).
+ *
+ * A *separate* map, not a field read off {@link lastAgentEvent}, and that is the
+ * whole point of it. `lastAgentEvent` is replaced wholesale on every delivery,
+ * and Claude puts the model on `SessionStart` and on nothing else — so the very
+ * next `UserPromptSubmit` would overwrite the only record that ever knew it, and
+ * the UI would show the model for the fraction of a second between session start
+ * and the first prompt. Keeping the last *non-null* sighting separately is what
+ * makes "which model is this session on" answerable at all for that tool.
+ *
+ * Never written with null: absent means "nothing has ever said", which is the
+ * honest state for gemini, copilot, and any session that predates this server
+ * process. See {@link getLastKnownAgentModel}.
+ */
+const lastAgentModel = globalThis.__agentEventLastModel ??
+    (globalThis.__agentEventLastModel = new Map());
+/**
+ * compositeKey -> what the terminal frame last showed for this instance (#1784).
+ *
+ * The second source, and a strictly different kind of fact from
+ * {@link lastAgentModel}: that one is the agent naming itself over the hook
+ * channel, this one is the TUI's own chrome read back off the screen. It is
+ * kept apart rather than folded into the first map because the two have a
+ * precedence between them ({@link getResolvedAgentModelInfo}) — merging on write
+ * would let a scraped display name ("Gemini 3.7 Flash") overwrite the exact id
+ * the agent reported, with nothing left to recover it from.
+ *
+ * Latched the same way and for a sharper reason: Claude prints its model in the
+ * startup banner and nowhere else, and tmux keeps 2000 lines of history, so on
+ * any session that has been talking for a while the banner is simply gone. The
+ * screen going quiet is not the model changing, so the last non-null sighting
+ * stands until the process it described does not (see
+ * {@link beginAgentEventGeneration} / {@link discardAgentEventState}).
+ */
+const capturedModelInfo = globalThis.__agentCapturedModelInfo ??
+    (globalThis.__agentCapturedModelInfo = new Map());
 /**
  * How long two identical events count as one delivery.
  *
@@ -124,6 +174,12 @@ function getLastStopEventAt(worktreeId, cliToolId, instanceId) {
 function recordAgentEvent(worktreeId, cliToolId, instanceId, record) {
     const key = (0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId);
     lastAgentEvent.set(key, record);
+    // Issue #1783: latch, never clear. An event without a model is the ordinary
+    // case (Claude sends one on `SessionStart` alone), and reading it as "the
+    // model is now unknown" would blank the display on the very next event.
+    if (typeof record.model === 'string' && record.model !== '') {
+        lastAgentModel.set(key, record.model.slice(0, agent_event_types_1.MAX_EVENT_DETAIL_LENGTH));
+    }
     applyAskUserQuestionTransition(key, record);
     if (record.event === 'session_start') {
         // The agent restarting inside a pane CommandMate never touched — `claude`
@@ -134,6 +190,92 @@ function recordAgentEvent(worktreeId, cliToolId, instanceId, record) {
         generationStartedAt.set(key, record.at);
     }
     applyPromptWaitingTransition(key, record);
+    applyAwaitingInstructionTransition(key, record);
+}
+/**
+ * The third state: "this turn is over and nobody has told me what to do next"
+ * (Issue #1786).
+ *
+ * | event                             | effect on awaiting_instruction |
+ * |-----------------------------------|--------------------------------|
+ * | `notification(idle_prompt)`       | **set**                        |
+ * | `user_prompt_submit`              | release                        |
+ * | `session_start` / `session_end`   | release                        |
+ * | everything else                   | unchanged                      |
+ *
+ * It is a boolean beside the status rather than a fifth `SessionStatus`, because
+ * `idle_prompt` already maps to `ready` (`agentEventToSessionStatus`) and
+ * `ready` means "you can send a message" everywhere in this codebase — the
+ * sidebar, `deriveCliStatus`, `getNextAction`, `commandmate wait`. Widening that
+ * vocabulary to carry "and it is *asking* you to" would have every consumer of
+ * the four values re-decide what they mean; the boolean asks nothing of anyone
+ * who does not want it.
+ *
+ * `stop` deliberately does NOT set it. `Stop` fires when the turn ends, which is
+ * most of the time the agent has simply finished a step of its own plan;
+ * `Notification(idle_prompt)` is Claude's separate, later "waiting for your
+ * input" signal, and using the turn boundary instead would mark every
+ * intermediate stop as a request for instructions.
+ *
+ * `pre_tool_use` / `post_tool_use` / `notification(permission_prompt)` leave it
+ * alone, and that is not a gap: a tool call or a dialog can only happen inside a
+ * turn, and the turn's own `user_prompt_submit` has already released it. Adding
+ * them would only paper over a `UserPromptSubmit` that never arrived — and an
+ * operator whose `UserPromptSubmit` hook is missing has no `Notification` hook
+ * either, so there would be nothing to release.
+ *
+ * There is deliberately no age bound here, unlike every other state in this
+ * module. Those bound the damage of an event that may never arrive (a lost
+ * `Stop`, a dialog answered with no event to say so). This one is released by
+ * events that cannot be missed while the fact is still true: typing into the
+ * composer — from the app or straight into the tmux pane — raises
+ * `UserPromptSubmit`, and ending the session raises `SessionEnd`. An agent that
+ * has been idle for six hours genuinely is still awaiting instructions, and
+ * expiring the flag would erase the notification #1790 exists to send. The
+ * generation fence in {@link isAwaitingInstruction} still applies, so the flag
+ * never survives the process that reported it.
+ */
+function applyAwaitingInstructionTransition(key, record) {
+    switch (record.event) {
+        case 'notification':
+            if (record.detail === 'idle_prompt') {
+                awaitingInstruction.set(key, { at: record.at, message: record.message ?? null });
+            }
+            return;
+        case 'user_prompt_submit':
+        case 'session_start':
+        case 'session_end':
+            awaitingInstruction.delete(key);
+            return;
+        case 'stop':
+        case 'pre_tool_use':
+        case 'post_tool_use':
+            return;
+        default:
+            // exhaustive check: a new AgentEventType must decide its transition here
+            record.event;
+            return;
+    }
+}
+/**
+ * The agent's own "waiting for your input", or null (Issue #1786).
+ *
+ * Fenced by generation like the rest of this module: an `idle_prompt` from the
+ * Claude process that used to live in this pane is not this one's.
+ */
+function getAwaitingInstruction(worktreeId, cliToolId, instanceId) {
+    const key = (0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId);
+    const record = awaitingInstruction.get(key);
+    if (!record)
+        return null;
+    const generation = generationStartedAt.get(key);
+    if (generation !== undefined && record.at < generation)
+        return null;
+    return record;
+}
+/** {@link getAwaitingInstruction} as the boolean the list API publishes. */
+function isAwaitingInstruction(worktreeId, cliToolId, instanceId) {
+    return getAwaitingInstruction(worktreeId, cliToolId, instanceId) !== null;
 }
 /**
  * The `prompt_waiting` half of the state machine, driven by the same events
@@ -221,6 +363,97 @@ function applyPromptWaitingTransition(key, record) {
 function getLastAgentEvent(worktreeId, cliToolId, instanceId) {
     return lastAgentEvent.get((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId)) ?? null;
 }
+/**
+ * The last model this instance reported running, or null (Issue #1783).
+ *
+ * "Last **non-null**", which is the only useful reading: three of the four tools
+ * that publish a model publish it on some events and not others, and Claude
+ * publishes it on exactly one. Reading `getLastAgentEvent()?.model` would
+ * therefore answer null for almost every moment of almost every session.
+ *
+ * Deliberately **not** bounded by {@link STRUCTURED_STATE_MAX_AGE_MS}, unlike
+ * every other reader in this module. That bound exists because a *status* that
+ * nothing has refreshed is a claim about right now that may have expired — a
+ * lost `Stop` leaving the layer asserting `running` forever. A model is not that
+ * kind of claim: an eight-hour turn is on the same model at the end as at the
+ * start, and expiring it would blank the display on precisely the long-running
+ * sessions this is most useful for. What *is* honoured is identity: a new
+ * generation or a discarded session drops the value, because the process that
+ * reported it is gone. See {@link beginAgentEventGeneration} /
+ * {@link discardAgentEventState}.
+ *
+ * In-memory only — nothing is written to `session_states`. After a server
+ * restart codex and antigravity repopulate on their next event; Claude stays
+ * null until its next `SessionStart`, a gap Phase 2 (#1784) closes from the
+ * terminal frame.
+ */
+function getLastKnownAgentModel(worktreeId, cliToolId, instanceId) {
+    return lastAgentModel.get((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId)) ?? null;
+}
+/**
+ * Latch what a terminal capture showed for this instance (Issue #1784).
+ *
+ * Called from the status-detection poll with the text that poll already
+ * captured — no `capture-pane` is issued for this, so the feature costs nothing
+ * in tmux round-trips.
+ *
+ * **Each half latches independently.** A Codex footer carries a model on every
+ * frame but an effort only on some formats; a Claude banner carries both and
+ * then scrolls away entirely. Writing `{model, effort}` wholesale would let the
+ * frame that stopped showing one of them blank a value the other frame proved.
+ * Nothing is ever written as null: absent means "no frame has ever shown this",
+ * which is the honest state for gemini/copilot and for any session whose chrome
+ * this module has no rule for.
+ *
+ * @param info - {@link import('../../lib/detection/model-info-extractor').extractModelInfo}'s answer
+ */
+function recordCapturedModelInfo(worktreeId, cliToolId, instanceId, info) {
+    if (!info.model && !info.effort)
+        return;
+    const key = (0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId);
+    const previous = capturedModelInfo.get(key);
+    capturedModelInfo.set(key, {
+        model: info.model ? info.model.slice(0, agent_event_types_1.MAX_EVENT_DETAIL_LENGTH) : (previous?.model ?? null),
+        effort: info.effort ?? previous?.effort ?? null,
+    });
+}
+/**
+ * The last model/effort a terminal capture showed, both halves possibly null.
+ *
+ * The raw scraped value, before precedence is applied — {@link
+ * getResolvedAgentModelInfo} is what callers publishing to the UI or the API
+ * want. Exported for the tests and for anything that needs to tell "the screen
+ * said" apart from "the agent said".
+ */
+function getLastCapturedModelInfo(worktreeId, cliToolId, instanceId) {
+    const record = capturedModelInfo.get((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId));
+    return { model: record?.model ?? null, effort: record?.effort ?? null };
+}
+/**
+ * The model and reasoning effort to publish for this instance (Issue #1784).
+ *
+ * The single answer both surfaces should read: it folds the hook channel
+ * (#1783) together with the screen under the precedence documented on
+ * {@link mergeModelInfo} — hooks win for the model, the screen is the only
+ * source of effort for codex/claude, and antigravity's effort is derived from
+ * the id it reports rather than from its (renderer-truncated) status bar.
+ *
+ * Both halves may be null, and routinely are: no tool publishes an effort over
+ * hooks, and most tools publish neither. Callers omit the key rather than
+ * emitting null — see `CliToolSessionStatus`.
+ */
+function getResolvedAgentModelInfo(worktreeId, cliToolId, instanceId) {
+    return (0, model_info_extractor_1.mergeModelInfo)(cliToolId, getLastKnownAgentModel(worktreeId, cliToolId, instanceId), getLastCapturedModelInfo(worktreeId, cliToolId, instanceId));
+}
+/**
+ * The reasoning effort this instance is running at, or null (Issue #1784).
+ *
+ * Convenience reader over {@link getResolvedAgentModelInfo} for callers that
+ * want only the effort — `capture --json` and `instances` (#1785) among them.
+ */
+function getLastKnownAgentEffort(worktreeId, cliToolId, instanceId) {
+    return getResolvedAgentModelInfo(worktreeId, cliToolId, instanceId).effort;
+}
 /**
  * How long a structured verdict is trusted after the event that produced it
  * (Issue #1723).
@@ -266,6 +499,21 @@ function beginAgentEventGeneration(worktreeId, cliToolId, instanceId, at = Date.
     promptWaiting.delete(key);
     // Same reasoning for the question that dialog was asking (Issue #1726).
     askUserQuestion.delete(key);
+    // And for "waiting for your input" (Issue #1786): a new process has not asked
+    // for anything yet.
+    awaitingInstruction.delete(key);
+    // And for the model (Issue #1783): a new generation is a new agent process,
+    // which may have been launched on a different model entirely. Latching across
+    // one would show the *previous* process's model with nothing to correct it —
+    // Claude only re-reports on `SessionStart`, which lands moments later anyway.
+    // A `/clear` is deliberately not affected: it reaches `recordAgentEvent` as
+    // `session_end` + `session_start`, never this function.
+    lastAgentModel.delete(key);
+    // Issue #1784: same argument for what the screen showed. The latch exists to
+    // survive the banner scrolling away *within* one process; carrying it across
+    // a relaunch would show the old process's effort with no frame left that
+    // could contradict it. The next poll re-reads a live footer immediately.
+    capturedModelInfo.delete(key);
 }
 /**
  * @returns Epoch ms the current generation began, or null when no generation
@@ -290,6 +538,11 @@ function discardAgentEventState(worktreeId, cliToolId, instanceId) {
     generationStartedAt.delete(key);
     promptWaiting.delete(key);
     askUserQuestion.delete(key);
+    awaitingInstruction.delete(key);
+    // Issue #1783: the session that was on this model no longer exists.
+    lastAgentModel.delete(key);
+    // Issue #1784: nor does the pane its footer was read from.
+    capturedModelInfo.delete(key);
 }
 /**
  * The status this instance's structured events imply, or null when they imply
@@ -644,4 +897,11 @@ function clearAgentStopEvents() {
     generationStartedAt.clear();
     promptWaiting.clear();
     askUserQuestion.clear();
+    awaitingInstruction.clear();
+    // Issue #1783. CI runs with `fileParallelism: false`, so every suite in the
+    // repo shares this process — a model latched by one test would otherwise be
+    // read by another, in file order, and only in CI.
+    lastAgentModel.clear();
+    // Issue #1784: and the same for the scraped half.
+    capturedModelInfo.clear();
 }

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

@@ -292,6 +292,14 @@ async function buildCurrentOutput(db, worktreeId, cliToolId, instanceId) {
             sessionStatusReason: 'session_not_running',
             lastStopEventAt: stopEventAt,
             structuredEvents,
+            // Issue #1785: null on a dead session, not the last model it ran. The
+            // latch outlives the process that filled it (by design — see
+            // getLastKnownAgentModel), so reporting it here would tell `commandmate
+            // instances` that a `RUNNING no` row is on gpt-5.6. The same holds for
+            // the effort, whose scraped half never expires either: dropping both is
+            // the server's job, done here and in exactly one place.
+            model: null,
+            reasoningEffort: null,
         };
     }
     const sessionState = (0, db_1.getSessionState)(db, worktreeId, resolvedInstanceId);
@@ -448,6 +456,18 @@ async function buildCurrentOutput(db, worktreeId, cliToolId, instanceId) {
     }
     const realtimeSnippet = lines.slice(-100).join('\n');
     const autoYesState = (0, auto_yes_manager_1.getAutoYesState)(worktreeId, cliToolId, instanceId);
+    // Issue #1785 + #1784: ONE resolution for both halves, not two readers.
+    //
+    // `getResolvedAgentModelInfo` is the reader #1784 documents as "the single
+    // answer both surfaces should read", and it is already what the list API
+    // publishes (`worktree-status-helper`). Reading the model off the hook latch
+    // here while taking the effort from the resolver would let this payload
+    // publish an effort with no model — the exact shape `buildModelByInstance`
+    // calls "unreachable through the API" — on a claude session whose banner the
+    // poller scraped before its first `SessionStart` hook arrived. It also folds
+    // in antigravity's rule that the effort comes from the model id, which a bare
+    // read of the scraped half would drop.
+    const { model, effort } = (0, agent_event_state_1.getResolvedAgentModelInfo)(worktreeId, cliToolId, instanceId);
     return {
         isRunning: true,
         cliToolId,
@@ -477,5 +497,9 @@ async function buildCurrentOutput(db, worktreeId, cliToolId, instanceId) {
         serverPollerActive: (0, auto_yes_manager_1.isPollerActive)(compositeKey),
         lastStopEventAt: stopEventAt,
         structuredEvents,
+        // Issue #1785: straight from the retention layer, unparsed. See the field
+        // docs on CurrentOutputPayload for why nothing is normalised on the way out.
+        model,
+        reasoningEffort: effort,
     };
 }

package/dist/server/src/lib/session/next-action-helper.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * Next Action Helper - Derived state for worktree next actions and review status.
+ *
+ * Issue #600: UX refresh - provides getNextAction() and getReviewStatus()
+ * for Review screen and WorktreeCard display.
+ *
+ * Uses exhaustive check (satisfies never) pattern to catch future
+ * SessionStatus extensions at compile time [DR2-005].
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NEXT_ACTION_KEYS = void 0;
+exports.isNextActionKey = isNextActionKey;
+exports.getNextAction = getNextAction;
+exports.getReviewStatus = getReviewStatus;
+/**
+ * Dictionary keys returned by {@link getNextAction} (Issue #1787).
+ *
+ * These are keys in the `worktree` namespace (`locales/{en,ja}/worktree.json`),
+ * NOT display strings: the function runs on the server (`/api/worktrees`) and in
+ * module scope, where `t()` cannot be called, so pinning English here would ship
+ * "Approve / Reject" to a Japanese UI — the same problem #1271/#1273 fixed for
+ * StatusDot's labels. Rendering surfaces resolve them with
+ * `useTranslations('worktree')`.
+ */
+exports.NEXT_ACTION_KEYS = {
+    start: 'nextAction.start',
+    sendMessage: 'nextAction.sendMessage',
+    approveReject: 'nextAction.approveReject',
+    replyToPrompt: 'nextAction.replyToPrompt',
+    checkStalled: 'nextAction.checkStalled',
+    running: 'nextAction.running',
+};
+const NEXT_ACTION_KEY_SET = new Set(Object.values(exports.NEXT_ACTION_KEYS));
+/**
+ * Whether a value is a key this module produces (Issue #1787).
+ *
+ * `Worktree.nextAction` is a plain `string` on the wire, and a server that
+ * predates this Issue still sends the old English literal. Callers must gate
+ * `t()` on this: next-intl reports a missing key by rendering the key path, so
+ * feeding it `"Approve / Reject"` would put `worktree.Approve / Reject` on
+ * screen. Anything that fails this test is rendered verbatim instead.
+ */
+function isNextActionKey(value) {
+    return NEXT_ACTION_KEY_SET.has(value);
+}
+/**
+ * Determine the next action for a given session state.
+ *
+ * @param status - Current session status (idle/ready/running/waiting) or null
+ * @param promptType - Type of active prompt, if any
+ * @param isStalled - Whether the session is considered stalled
+ * @returns A dictionary key from {@link NEXT_ACTION_KEYS} (Issue #1787 — this
+ *   used to be a hard-coded English string)
+ */
+function getNextAction(status, promptType, isStalled) {
+    if (!status)
+        return exports.NEXT_ACTION_KEYS.start;
+    if (status === 'idle')
+        return exports.NEXT_ACTION_KEYS.start;
+    if (status === 'ready')
+        return exports.NEXT_ACTION_KEYS.sendMessage;
+    if (status === 'waiting' && promptType === 'approval')
+        return exports.NEXT_ACTION_KEYS.approveReject;
+    if (status === 'waiting')
+        return exports.NEXT_ACTION_KEYS.replyToPrompt;
+    if (status === 'running' && isStalled)
+        return exports.NEXT_ACTION_KEYS.checkStalled;
+    if (status === 'running')
+        return exports.NEXT_ACTION_KEYS.running;
+    // exhaustive check: SessionStatus extensions will cause compile error [DR2-005]
+    const _exhaustive = status;
+    void _exhaustive;
+    return exports.NEXT_ACTION_KEYS.running;
+}
+/**
+ * Determine the review status for a worktree.
+ *
+ * @param worktreeStatus - Worktree's status field (ready/in_progress/in_review/done/null)
+ * @param sessionStatus - Current session status or null
+ * @param promptType - Type of active prompt, if any
+ * @param isStalled - Whether the session is considered stalled
+ * @returns ReviewStatus if applicable, null otherwise
+ */
+function getReviewStatus(worktreeStatus, sessionStatus, promptType, isStalled) {
+    if (worktreeStatus === 'in_review')
+        return 'done';
+    if (sessionStatus === 'waiting' && promptType === 'approval')
+        return 'approval';
+    if (sessionStatus === 'running' && isStalled)
+        return 'stalled';
+    return null;
+}

package/dist/server/src/lib/session/prompt-waiting-composition.js

@@ -35,6 +35,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.STRUCTURED_SEND_GUARD_ENV = exports.STRUCTURED_SEND_BLOCK_MAX_AGE_MS = void 0;
 exports.structuredWaitingReason = structuredWaitingReason;
 exports.resolvePromptWaiting = resolvePromptWaiting;
+exports.peekPromptWaiting = peekPromptWaiting;
 const agent_event_state_1 = require("../../lib/session/agent-event-state");
 const status_mapping_1 = require("../../lib/session/status-mapping");
 /**
@@ -160,6 +161,43 @@ function resolvePromptWaiting({ worktreeId, cliToolId, instanceId, scraper, igno
         structuredSendBlockSuppressed: suppressed,
     };
 }
+/**
+ * The OR rule without the release rule: read both layers, change neither
+ * (Issue #1786).
+ *
+ * Added for the list API (`/api/worktrees`), which had been publishing the
+ * scraper's verdict alone and therefore showed no dot at all for a dialog only
+ * the agent's events could see. It needs the composed answer; what it must not
+ * have is {@link resolvePromptWaiting}'s side effects, for three reasons:
+ *
+ *  - **it is not the same evidence.** The list path detects on
+ *    `STATUS_DETECTION_CAPTURE_LINES`, a deliberately smaller window than the
+ *    detail path's, so its "no prompt here" is a weaker statement than the one
+ *    the release rule was written for. Letting it clear a corroborated episode
+ *    would retire a record on evidence #1725 never intended.
+ *  - **`blocksSend` reads the same record.** A list poll that wrongly cleared it
+ *    would silently disarm the `send` guard — the #1708 hazard, restored by a
+ *    read endpoint. The Issue's own instruction is that `blocksSend` must not
+ *    change, and the cheapest way to guarantee that is to write nothing.
+ *  - **it is polled by every open tab, for every worktree.** A state machine
+ *    whose outcome depends on how many browsers are watching is not one anybody
+ *    can reason about later.
+ *
+ * What the list path gives up is arming corroboration. It costs nothing that was
+ * ever there: the arming callers (`current-output-builder`, the `send` guard)
+ * are unchanged, and the structured record's own releases — `Stop`,
+ * `user_prompt_submit`, `post_tool_use`, `Notification(idle_prompt)`, a
+ * generation change — are what retire it in the ordinary case, with
+ * {@link agent-event-state!STRUCTURED_STATE_MAX_AGE_MS} as the backstop.
+ */
+function peekPromptWaiting({ worktreeId, cliToolId, instanceId, scraper, now = Date.now(), }) {
+    const structured = (0, agent_event_state_1.getStructuredPromptWaiting)(worktreeId, cliToolId, instanceId, now);
+    return {
+        waiting: scraper.hasActivePrompt || structured !== null,
+        scraperWaiting: scraper.hasActivePrompt,
+        structured,
+    };
+}
 /**
  * Why this structured record may not refuse a send, or null when it may.
  *

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

@@ -0,0 +1,136 @@
+"use strict";
+/**
+ * When each agent instance started waiting, and the one place that edge is
+ * observed (Issue #1786).
+ *
+ * `isWaitingForResponse` is a level, and every question the display Issues ask
+ * is about the *edge*: #1787 wants "waiting for how long", #1788 wants to push a
+ * WebSocket frame the instant it flips, #1790 wants to fire a push notification
+ * on the same instant and not on the 200 polls that follow. A level cannot
+ * answer any of those, and three surfaces each keeping their own "was it waiting
+ * last time?" would be three chances to disagree about when a wait began.
+ *
+ * So the edge is detected exactly once, here, by {@link observeWaitingEdge}, and
+ * everything else either reads {@link getWaitingEpisode} or subscribes with
+ * {@link onWaitingTransition}. There is one caller today —
+ * `worktree-status-helper`, on the list API's per-instance probe — and it passes
+ * the *composed* verdict (scraper OR structured), so a wait that only the
+ * agent's own events can see opens an episode exactly like one the screen
+ * scraper read.
+ *
+ * ## Where #1788 / #1790 plug in
+ *
+ * `onWaitingTransition(listener)` — the listener receives every false→true and
+ * true→false crossing, with the instance it belongs to, the episode's `since`
+ * and its {@link WaitingKind}. #1788 broadcasts it (`broadcastToWorktree`),
+ * #1790 decides whether to send a push. Neither needs to touch this module's
+ * internals, and neither can move the timestamps the other reports.
+ *
+ * Listeners are called synchronously, inside the request that observed the edge,
+ * because the point of the seam is immediacy. A listener that throws is
+ * contained: this store is on the list API's hot path, and a broken notification
+ * sink must not take the status read down with it.
+ *
+ * In-memory (via `globalThis`, per Issue #1736 — see the note in
+ * `agent-event-state`) rather than SQLite, for the same reason the structured
+ * state is: it describes a live tmux session, and a wait does not outlive the
+ * server process that observed it.
+ *
+ * @module lib/session/waiting-episode-state
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onWaitingTransition = onWaitingTransition;
+exports.observeWaitingEdge = observeWaitingEdge;
+exports.getWaitingEpisode = getWaitingEpisode;
+exports.clearWaitingEpisodes = clearWaitingEpisodes;
+exports.clearWaitingTransitionListeners = clearWaitingTransitionListeners;
+const auto_yes_state_1 = require("../../lib/auto-yes-state");
+const logger_1 = require("../../lib/logger");
+const logger = (0, logger_1.createLogger)('waiting-episode-state');
+/** compositeKey -> the wait currently in progress for that instance. */
+const episodes = globalThis.__sessionWaitingEpisodes ??
+    (globalThis.__sessionWaitingEpisodes = new Map());
+/** Subscribers to the edge. See the module docblock. */
+const listeners = globalThis.__sessionWaitingTransitionListeners ??
+    (globalThis.__sessionWaitingTransitionListeners = new Set());
+/**
+ * Subscribe to waiting edges.
+ *
+ * @returns An unsubscribe function. Idempotent — calling it twice is harmless.
+ */
+function onWaitingTransition(listener) {
+    listeners.add(listener);
+    return () => {
+        listeners.delete(listener);
+    };
+}
+/** Notify subscribers, containing anything they throw. */
+function emit(transition) {
+    for (const listener of listeners) {
+        try {
+            listener(transition);
+        }
+        catch (error) {
+            logger.error('waiting-transition-listener-failed', {
+                worktreeId: transition.worktreeId,
+                cliToolId: transition.cliToolId,
+                instanceId: transition.instanceId ?? transition.cliToolId,
+                waiting: transition.waiting,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+}
+/**
+ * Record this poll's waiting verdict and answer when the current wait began.
+ *
+ * The single writer of the edge, by design (Issue #1786). Idempotent for a
+ * level that has not changed: repeated `waiting: true` polls return the same
+ * `since` and emit nothing, so a listener hears one event per wait rather than
+ * one per poll.
+ *
+ * @returns The episode's `since` while waiting, or null when it is not.
+ */
+function observeWaitingEdge({ worktreeId, cliToolId, instanceId, waiting, kind = null, structuredSince = null, now = Date.now(), }) {
+    const key = (0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId);
+    const existing = episodes.get(key);
+    if (!waiting) {
+        if (existing === undefined)
+            return null;
+        episodes.delete(key);
+        emit({ worktreeId, cliToolId, instanceId, waiting: false, since: null, kind: null, at: now });
+        return null;
+    }
+    if (existing !== undefined) {
+        // A wait can change character without ending — a permission dialog answered
+        // into a selection list is still one uninterrupted wait — so the kind is
+        // refreshed while `since` stays put.
+        existing.kind = kind;
+        return existing.since;
+    }
+    const since = structuredSince ?? now;
+    episodes.set(key, { since, kind });
+    emit({ worktreeId, cliToolId, instanceId, waiting: true, since, kind, at: now });
+    return since;
+}
+/**
+ * @returns The wait in progress for this instance, or null when it is not
+ *   waiting. Read-only: observing the edge is {@link observeWaitingEdge}'s job.
+ */
+function getWaitingEpisode(worktreeId, cliToolId, instanceId) {
+    return episodes.get((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId)) ?? null;
+}
+/**
+ * Drop every episode. Test seam.
+ *
+ * CI runs with `fileParallelism: false`, so one process holds this map for the
+ * whole suite: a test that opens an episode and does not clear it hands the next
+ * file a session that is already waiting.
+ */
+function clearWaitingEpisodes() {
+    episodes.clear();
+}
+/** Drop every subscriber. Test seam, paired with {@link clearWaitingEpisodes}. */
+function clearWaitingTransitionListeners() {
+    listeners.clear();
+}