commandmate 0.22.2 → 0.24.0

package/dist/server/src/lib/hooks/sources/opencode/turn-gate.js

@@ -0,0 +1,193 @@
+"use strict";
+/**
+ * Deciding which frames are a turn's real boundaries (Issue #1763).
+ *
+ * opencode repeats both of the frames CommandMate reads as one-off facts, and
+ * in both cases the repeat is byte-identical to the original. A source that
+ * mapped frames one-to-one would therefore report the same event several times,
+ * and the status layer — which reads only the *newest* event — would turn that
+ * into a wrong verdict. This module tells the first from the rest.
+ *
+ * ## `session.idle` — the end of a turn
+ *
+ * It is opencode's `Stop`: #1758 §5.3.1 held a session on an approval dialog
+ * for 10 minutes 19 seconds and not one `session.idle` arrived for it, so the
+ * event really does mean "the turn finished" rather than "the agent is not
+ * busy". `commandmate wait` may key off it. What it may not do is count them:
+ *
+ *  - **Abnormal endings fire twice.** An abort emitted `session.idle` at
+ *    08:15:00.416 and again at 08:15:00.435 — 19 ms apart, same session, same
+ *    turn (§5.3.2). Provider errors do the same. Normal endings fire once.
+ *  - **The payload has no turn identifier.** It is `{ "sessionID": "ses_…" }`
+ *    and nothing else, so two idles cannot be told apart by looking at them
+ *    (§5.3.3). Claude's `Stop` carried `prompt_id`; this does not.
+ *  - **An idle can arrive for a turn this connection never watched start** — a
+ *    stream opened mid-session, a resubscribe after a restart — and treating
+ *    that as a completion resolves a `wait` for work that is not over.
+ *
+ * So: **arm on `session.status(busy)`, complete on the first `session.idle`
+ * after arming, drop the rest.** `session.status(idle)` is deliberately inert —
+ * it is emitted in the same millisecond as `session.idle` and is the same
+ * signal, so honouring both would double every turn (§5.3.2 rule 4).
+ *
+ * ## `message.updated` — the start of a turn
+ *
+ * `user_prompt_submit` has no event of its own; it is `message.updated` with
+ * `info.role === "user"`. That frame is **re-emitted for the same message
+ * several times per turn, including after `session.idle`** — measured live on
+ * 1.18.3 while implementing this Issue:
+ *
+ * ```
+ * 13:53:14.251  session.idle
+ * 13:53:14.297  message.updated  role=user  id=msg_ffb668eec001WToZ7VW0lQgmoa
+ * ```
+ *
+ * Both copies carry `time: { created: … }` and nothing else, so nothing in the
+ * payload distinguishes them. Mapped one-to-one, the newest event after a
+ * finished turn is `user_prompt_submit`, which `status-mapping` reads as
+ * **`running`** — so `commandmate wait` would hang on every completed opencode
+ * turn until the 30-minute staleness bound expired. The fix has the same shape:
+ * **announce the first `message.updated` for a message id, suppress the
+ * repeats.**
+ *
+ * Unlike the arming state, announced ids **survive a reconnect**. A genuinely
+ * new prompt always carries a new id, so keeping them costs nothing and closes
+ * the window where a reconnect lands between a turn's end and its trailing
+ * repeat.
+ *
+ * The gate is a pure state machine over frame types so it can be driven from
+ * fixtures. The subscription owns one per connection.
+ *
+ * @module lib/hooks/sources/opencode/turn-gate
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_TRACKED_USER_MESSAGES = exports.MAX_TRACKED_TURN_SESSIONS = void 0;
+exports.createTurnGate = createTurnGate;
+const event_mapper_1 = require("../event-mapper");
+/**
+ * Cap on remembered sessions.
+ *
+ * One opencode server can host several sessions (#1758 §5.6.1) and a long-lived
+ * TUI accumulates them, so the map is bounded. The oldest is dropped, which at
+ * worst re-arms an ancient session — the failure mode of forgetting is a
+ * suppressed idle, never a spurious completion.
+ */
+exports.MAX_TRACKED_TURN_SESSIONS = 64;
+/**
+ * Cap on remembered user-message ids.
+ *
+ * Larger than the session cap because it counts prompts rather than sessions,
+ * and because these survive reconnects. Forgetting the oldest costs one
+ * re-announced `user_prompt_submit` for a prompt from thousands of turns ago.
+ */
+exports.MAX_TRACKED_USER_MESSAGES = 512;
+/** `properties.sessionID`, or null. */
+function sessionIdOf(payload) {
+    const properties = (0, event_mapper_1.isPlainObject)(payload.properties) ? payload.properties : {};
+    return (0, event_mapper_1.readNestedString)(properties, ['sessionID']);
+}
+/** `properties.status.type` for `session.status`. */
+function statusType(payload) {
+    const properties = (0, event_mapper_1.isPlainObject)(payload.properties) ? payload.properties : {};
+    return (0, event_mapper_1.readNestedString)(properties, ['status', 'type']);
+}
+/** `properties.error.name` for `session.error` — `MessageAbortedError`, `APIError`, … */
+function errorName(payload) {
+    const properties = (0, event_mapper_1.isPlainObject)(payload.properties) ? payload.properties : {};
+    return (0, event_mapper_1.readNestedString)(properties, ['error', 'name']);
+}
+/** `properties.info.role` / `properties.info.id` for `message.updated`. */
+function messageInfo(payload) {
+    const properties = (0, event_mapper_1.isPlainObject)(payload.properties) ? payload.properties : {};
+    return {
+        role: (0, event_mapper_1.readNestedString)(properties, ['info', 'role']),
+        id: (0, event_mapper_1.readNestedString)(properties, ['info', 'id']),
+    };
+}
+/** Drop the oldest entries until the collection fits. */
+function trim(keys, max) {
+    // Both Map and Set iterate in insertion order, so the head is the oldest.
+    while (keys.size > max) {
+        const oldest = keys.keys().next();
+        if (oldest.done)
+            break;
+        keys.delete(oldest.value);
+    }
+}
+/**
+ * Build a gate.
+ *
+ * @param maxSessions - Cap on remembered sessions; defaults to
+ *   {@link MAX_TRACKED_TURN_SESSIONS}
+ * @param maxUserMessages - Cap on remembered user-message ids; defaults to
+ *   {@link MAX_TRACKED_USER_MESSAGES}
+ */
+function createTurnGate(maxSessions = exports.MAX_TRACKED_TURN_SESSIONS, maxUserMessages = exports.MAX_TRACKED_USER_MESSAGES) {
+    const phases = new Map();
+    const announced = new Set();
+    const remember = (sessionId, phase) => {
+        phases.delete(sessionId);
+        phases.set(sessionId, phase);
+        trim(phases, maxSessions);
+    };
+    return {
+        observe(type, payload) {
+            if (type === 'message.updated') {
+                const { role, id } = messageInfo(payload);
+                // Only the user's own message is `user_prompt_submit`; the assistant's
+                // updates carry the reply and map to nothing.
+                if (role !== 'user' || id === null)
+                    return { kind: 'ignored' };
+                const sessionId = sessionIdOf(payload) ?? '';
+                if (announced.has(id)) {
+                    return { kind: 'suppressed', sessionId, reason: 'already-announced' };
+                }
+                announced.add(id);
+                trim(announced, maxUserMessages);
+                return { kind: 'announced', sessionId, messageId: id };
+            }
+            if (type === 'session.status') {
+                // Only `busy` arms. `idle` here is the same signal as `session.idle`,
+                // emitted in the same millisecond, and honouring both would count every
+                // turn twice (#1758 §5.3.2 rule 4).
+                if (statusType(payload) !== 'busy')
+                    return { kind: 'ignored' };
+                const sessionId = sessionIdOf(payload);
+                if (sessionId === null)
+                    return { kind: 'ignored' };
+                remember(sessionId, 'busy');
+                return { kind: 'armed', sessionId };
+            }
+            if (type === 'session.error') {
+                const sessionId = sessionIdOf(payload);
+                if (sessionId === null)
+                    return { kind: 'ignored' };
+                // Not a completion: the idle that follows is. Reported so the caller can
+                // tell "finished" from "gave up" — `session.idle` alone cannot (§5.3.3
+                // requirement 3).
+                return { kind: 'failed', sessionId, errorName: errorName(payload) };
+            }
+            if (type !== 'session.idle')
+                return { kind: 'ignored' };
+            const sessionId = sessionIdOf(payload);
+            if (sessionId === null)
+                return { kind: 'ignored' };
+            const phase = phases.get(sessionId);
+            if (phase === undefined) {
+                return { kind: 'suppressed', sessionId, reason: 'never-armed' };
+            }
+            if (phase === 'idle') {
+                return { kind: 'suppressed', sessionId, reason: 'already-completed' };
+            }
+            remember(sessionId, 'idle');
+            return { kind: 'completed', sessionId };
+        },
+        isArmed(sessionId) {
+            return phases.get(sessionId) === 'busy';
+        },
+        reset() {
+            phases.clear();
+            // `announced` is deliberately kept — see the module comment.
+        },
+    };
+}

package/dist/server/src/lib/hooks/sources/pending-decisions.js

@@ -0,0 +1,127 @@
+"use strict";
+/**
+ * The in-flight decisions a push source is holding, and the one call a receiver
+ * makes to answer one (Issue #1759, constraint C2).
+ *
+ * A hook is answered in the body of the request it arrived on. opencode is
+ * answered by `POST`ing to a different URL, minutes later if need be, on a
+ * connection the event never travelled over (#1758 §5.5). Those are not two
+ * spellings of one operation, and a receiver that branched on which it was
+ * dealing with would be a receiver that knows the tool — the thing this whole
+ * abstraction exists to remove.
+ *
+ * {@link answerPendingDecision} is the seam. It opens a slot, hands the
+ * decision to {@link AgentEventSource.decide}, and returns whatever body the
+ * source left behind — `{}` when the source answered out of band, because there
+ * is then nothing for the response to carry. A push source fills the slot
+ * synchronously; a pull source ignores it and calls REST. The caller writes the
+ * returned object either way.
+ *
+ * The open slots are also what {@link AgentEventSource.listPending} answers with
+ * for push sources (C7): a hook that has not been replied to yet is the only
+ * pending state a push transport has, and a hook that was dropped is simply
+ * gone — there is no `GET /permission` to re-read it from.
+ *
+ * @module lib/hooks/sources/pending-decisions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_OPEN_DECISIONS_PER_INSTANCE = void 0;
+exports.openDecisionSlot = openDecisionSlot;
+exports.closeDecisionSlot = closeDecisionSlot;
+exports.listOpenDecisions = listOpenDecisions;
+exports.fillDecisionSlot = fillDecisionSlot;
+exports.resetPendingDecisions = resetPendingDecisions;
+exports.answerPendingDecision = answerPendingDecision;
+const auto_yes_state_1 = require("../../../lib/auto-yes-state");
+const logger_1 = require("../../../lib/logger");
+const logger = (0, logger_1.createLogger)('lib/hooks/sources/pending-decisions');
+const pendingByInstance = (globalThis.__agentSourcePendingDecisions ??= new Map());
+/**
+ * Cap on simultaneously open slots for one instance.
+ *
+ * An agent asks one thing at a time, so anything above a handful means slots
+ * are leaking rather than that a human is very busy. The oldest is dropped
+ * rather than the newest refused: the newest is the one somebody is waiting on.
+ */
+exports.MAX_OPEN_DECISIONS_PER_INSTANCE = 16;
+function keyOf(ref) {
+    return (0, auto_yes_state_1.buildCompositeKey)(ref.worktreeId, ref.cliToolId, ref.instanceId);
+}
+/** Register a decision as in flight. Always paired with {@link closeDecisionSlot}. */
+function openDecisionSlot(ref, decision) {
+    const key = keyOf(ref);
+    const slot = { key, ref, decision, body: null };
+    const open = pendingByInstance.get(key) ?? [];
+    open.push(slot);
+    while (open.length > exports.MAX_OPEN_DECISIONS_PER_INSTANCE)
+        open.shift();
+    pendingByInstance.set(key, open);
+    return slot;
+}
+/**
+ * Remove a slot and take whatever the source wrote into it.
+ *
+ * @returns The response body, or `{}` when the source answered out of band —
+ *   which is also, and not by accident, the byte-for-byte no-decision body
+ *   every hook-based tool reads as "carry on" (#1721 D5).
+ */
+function closeDecisionSlot(slot) {
+    const open = pendingByInstance.get(slot.key);
+    if (open) {
+        const index = open.indexOf(slot);
+        if (index >= 0)
+            open.splice(index, 1);
+        if (open.length === 0)
+            pendingByInstance.delete(slot.key);
+    }
+    return slot.body ?? {};
+}
+/** The decisions currently in flight for one instance. */
+function listOpenDecisions(ref) {
+    return (pendingByInstance.get(keyOf(ref)) ?? []).map((slot) => slot.decision);
+}
+/** Fill the slot a push source is answering, if it is still open. */
+function fillDecisionSlot(ref, decisionId, body) {
+    const open = pendingByInstance.get(keyOf(ref));
+    if (!open)
+        return false;
+    const slot = open.find((candidate) => candidate.decision.id === decisionId);
+    if (!slot)
+        return false;
+    slot.body = body;
+    return true;
+}
+/** Drop every open slot. For tests; production only ever closes what it opened. */
+function resetPendingDecisions() {
+    pendingByInstance.clear();
+}
+/**
+ * Answer one decision, whichever way this source answers things.
+ *
+ * The single call a receiver route makes. It does not know — and after this
+ * function exists, cannot find out without going out of its way — whether the
+ * verdict left through the response body or through a second HTTP call.
+ *
+ * @returns The body to write. `{}` means "nothing to say here", which for a
+ *   hook is the measured no-decision reply and for a pull source is simply the
+ *   ack of a request whose answer went elsewhere.
+ */
+async function answerPendingDecision(source, ref, decision, verdict) {
+    const slot = openDecisionSlot(ref, decision);
+    try {
+        await source.decide(ref, decision, verdict);
+    }
+    catch (error) {
+        // Closed even when `decide` throws: a source that failed to deliver must
+        // still not leave the receiver holding a slot, and the empty body that then
+        // comes back is the fail-open answer for every push tool.
+        logger.warn('agent-source-decide-failed', {
+            worktreeId: ref.worktreeId,
+            cliToolId: ref.cliToolId,
+            instanceId: ref.instanceId ?? ref.cliToolId,
+            decisionId: decision.id,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+    return closeDecisionSlot(slot);
+}

package/dist/server/src/lib/hooks/sources/registry.js

@@ -0,0 +1,111 @@
+"use strict";
+/**
+ * Which {@link AgentEventSource} speaks for which CLI tool (Issue #1759).
+ *
+ * The lookup that replaces "assume Claude". A receiver holds a
+ * {@link CLIToolType} — it came off the hook URL or the request body — and asks
+ * here; it never imports a tool's module and never compares against a tool id.
+ *
+ * ## Held on `globalThis`
+ *
+ * Not decoration. `agent-event-state` documents what happened the last time a
+ * shared map lived in module scope (#1736): under `next dev` every route
+ * handler is bundled separately, so `/api/hooks/agent-event` and
+ * `/api/hooks/permission-request` each got their own copy of the module, one
+ * wrote and the other read, and every field came back null — with no error, no
+ * warning and a perfectly well-formed response. A registry has the same shape
+ * of failure available to it: a source registered in one bundle would be absent
+ * in another, and the fallback below would silently take over. So the map is
+ * process-wide, and the registration is idempotent.
+ *
+ * ## Unregistered tools
+ *
+ * {@link getAgentEventSource} always answers. A tool with no source gets the
+ * compatibility source from `./legacy-relay`, which preserves the pre-#1759
+ * receiver behaviour for the hand-configured hooks of #1549. Ask
+ * {@link hasAgentEventSource} when the distinction matters.
+ *
+ * @module lib/hooks/sources/registry
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAgentEventSource = registerAgentEventSource;
+exports.hasAgentEventSource = hasAgentEventSource;
+exports.getAgentEventSource = getAgentEventSource;
+exports.listAgentEventSources = listAgentEventSources;
+exports.unregisterAgentEventSource = unregisterAgentEventSource;
+const legacy_relay_1 = require("./legacy-relay");
+const source_1 = require("./claude/source");
+const source_2 = require("./copilot/source");
+const source_3 = require("./gemini/source");
+const source_4 = require("./antigravity/source");
+const source_5 = require("./codex/source");
+const source_6 = require("./opencode/source");
+const registered = (globalThis.__agentEventSources ??= new Map());
+/** Memoised compatibility sources, so repeated lookups return one object. */
+const legacy = (globalThis.__agentEventLegacySources ??= new Map());
+/**
+ * Add or replace a tool's source.
+ *
+ * @param source - The implementation; its own `cliToolId` is the key
+ */
+function registerAgentEventSource(source) {
+    registered.set(source.cliToolId, source);
+    // A tool that has a real source must not keep answering from the
+    // compatibility one anywhere — including from a memo taken before it was
+    // registered, which is reachable in `next dev` where registration order
+    // across bundles is not fixed.
+    legacy.delete(source.cliToolId);
+}
+/** Whether this tool has a real implementation, as opposed to the fallback. */
+function hasAgentEventSource(cliToolId) {
+    return registered.has(cliToolId);
+}
+/**
+ * The source for one tool. Never null.
+ *
+ * @returns The registered implementation, or the compatibility source that
+ *   keeps a hand-configured #1549 hook working until this tool has one
+ */
+function getAgentEventSource(cliToolId) {
+    const source = registered.get(cliToolId);
+    if (source)
+        return source;
+    const existing = legacy.get(cliToolId);
+    if (existing)
+        return existing;
+    const fallback = (0, legacy_relay_1.createLegacyRelaySource)(cliToolId);
+    legacy.set(cliToolId, fallback);
+    return fallback;
+}
+/** Every tool with a real implementation. Ordered by registration. */
+function listAgentEventSources() {
+    return [...registered.values()];
+}
+/**
+ * Undo a registration. For tests — production only ever adds.
+ *
+ * The mutation "take Claude out of the registry" that Issue #1759 asks to be
+ * proved lethal is spelled with this.
+ */
+function unregisterAgentEventSource(cliToolId) {
+    registered.delete(cliToolId);
+    legacy.delete(cliToolId);
+}
+// ---------------------------------------------------------------------------
+// Built-in registrations
+// ---------------------------------------------------------------------------
+//
+// Statically imported and registered on load, rather than through a
+// side-effecting `import './claude'` somewhere else: an import a bundler is
+// free to consider unused is a registration that disappears in a production
+// build, and "the source is silently absent" is the exact failure this module's
+// globalThis comment is about.
+//
+// Phase 4-2…4-5 adds one line here per tool. That, plus the tool's own file, is
+// the whole of "adding a tool" — see docs/design/agent-event-source-interface.md.
+registerAgentEventSource(source_1.claudeAgentEventSource);
+registerAgentEventSource(source_2.copilotAgentEventSource);
+registerAgentEventSource(source_3.geminiAgentEventSource);
+registerAgentEventSource(source_4.antigravityAgentEventSource);
+registerAgentEventSource(source_5.codexAgentEventSource);
+registerAgentEventSource(source_6.opencodeAgentEventSource);

package/dist/server/src/lib/hooks/sources/types.js

@@ -0,0 +1,46 @@
+"use strict";
+/**
+ * `AgentEventSource` — the one seam every agent CLI plugs its lifecycle events
+ * into (Issue #1759, Phase 4-1 of Epic #1720).
+ *
+ * Phases 1-3 left the *consuming* half of the structured-event pipeline already
+ * tool-agnostic: `agent-event-state`, `permission-decision-service`,
+ * `current-output-builder`, `status-mapping` and `prompt-waiting-composition`
+ * all key off `(worktreeId, cliToolId, instanceId)` and branch on nothing else.
+ * What stayed Claude-shaped is the half that *produces* the events and the half
+ * that *answers* them. This module is the contract for that half, so Phase
+ * 4-2…4-5 adds a tool by adding a file rather than by copying Claude's seams.
+ *
+ * Every type below exists because a measurement demanded it. The two spikes
+ * that took those measurements are the specification:
+ *
+ *  - `docs/design/agent-hooks-phase4-live-verification.md` (#1757) — codex /
+ *    copilot / gemini / antigravity, five push-mode hook implementations that
+ *    disagree with each other about spelling, casing, correlation keys, config
+ *    location and — most importantly — what silence means.
+ *  - `docs/design/opencode-server-live-verification.md` (#1758) — opencode,
+ *    which is not a hook implementation at all: CommandMate subscribes to *its*
+ *    HTTP server over SSE and answers with a separate REST call. §9.1 of that
+ *    report lists eight constraints (C1…C8) and §9.2 sketches this interface;
+ *    the shapes here follow it.
+ *
+ * Three of those constraints are worth restating at the top of the file,
+ * because getting them wrong is silent:
+ *
+ *  - **C1 — the direction of travel is not fixed.** Hooks push into
+ *    `POST /api/hooks/agent-event`. opencode has to be *subscribed to*. So a
+ *    source has a lifecycle (`subscribe` / `Subscription.close`), even when
+ *    the push implementations make it a no-op.
+ *  - **C2 — the reply channel is not fixed.** A hook is answered in the body of
+ *    the request it arrived on; opencode is answered by `POST`ing to a
+ *    different URL entirely. {@link AgentEventSource.decide} hides which.
+ *  - **C3 — silence does not mean the same thing twice.** Claude / codex /
+ *    copilot walk on when nobody answers (fail-open). antigravity reads an
+ *    empty object as *deny* and stops every tool call. opencode waits forever
+ *    (10m19s measured, no timeout). {@link NoDecisionBehavior} is a declared
+ *    field for exactly this reason: "we abstain, which is the safe default" is
+ *    a sentence that is only true for some of the tools.
+ *
+ * @module lib/hooks/sources/types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -28,7 +28,20 @@ const prompt_dedup_1 = require("./prompt-dedup");
 const response_dedup_1 = require("./response-dedup");
 const response_poller_core_1 = require("./response-poller-core");
 const push_1 = require("../../lib/push");
+// Issue #1790: imported by deep path, not through `@/lib/push`. Suites that
+// replace the barrel to count notifications (e.g. the #1547 escalation test)
+// would otherwise get `undefined` here and take down module evaluation.
+const waiting_push_notifier_1 = require("../../lib/push/waiting-push-notifier");
+const waiting_episode_state_1 = require("../../lib/session/waiting-episode-state");
 const task_transition_service_1 = require("../../lib/tasks/task-transition-service");
+// Issue #1790: arm the waiting-edge push subscription.
+//
+// It has to exist before the first edge, and `server.ts` reaches this module at
+// boot (it imports `polling/response-poller` for `stopAllPolling`, which pulls
+// in `response-poller-core` and then this file), so this is the earliest hook
+// the notification path owns. Idempotent by replacement, and it starts no timer
+// and touches no database until a wait actually opens.
+(0, waiting_push_notifier_1.startWaitingPushNotifier)();
 /**
  * Creates an incomplete extraction result with empty response.
  * Centralizes the repeated pattern of returning an in-progress/incomplete state.
@@ -465,13 +478,39 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
             });
             // Web Push fan-out (Issue #1125): agent is now waiting for a prompt reply.
             // Fire-and-forget — push is advisory and must never block/break the poller.
+            //
+            // Issue #1790: the wait is now named by #1786's episode rather than by the
+            // prompt text. The two lines below are ordered, not incidental:
+            //
+            //  1. the notification is raised first, while it still has the prompt's
+            //     own question to quote — it records the episode in the dedup, so
+            //     whichever path reports the wait second says nothing;
+            //  2. `observeWaitingEdge` then opens that same episode, which is what
+            //     lets the edge listener (and #1788's WebSocket frame) agree with this
+            //     call about *which* wait this is instead of raising a second one.
+            //
+            // Both use one timestamp so the episode the notification claims and the
+            // episode the store opens are the same number.
+            const promptObservedAt = Date.now();
+            const promptWaitingSince = (0, waiting_episode_state_1.getWaitingEpisode)(worktreeId, cliToolId, instanceId)?.since ?? promptObservedAt;
             void (0, push_1.notifyPushSubscribers)({
                 worktreeId,
                 worktreeName: worktree.name,
                 kind: 'prompt',
                 agentName: resolvedInstanceId,
+                instanceId: resolvedInstanceId,
+                waitingKind: 'prompt',
+                waitingSince: promptWaitingSince,
                 excerpt: promptDetection.promptData?.question ?? promptSaveContent,
             }).catch(() => { });
+            (0, waiting_episode_state_1.observeWaitingEdge)({
+                worktreeId,
+                cliToolId,
+                instanceId,
+                waiting: true,
+                kind: 'prompt',
+                now: promptObservedAt,
+            });
             if (!isFullScreenTui) {
                 (0, response_poller_core_1.stopPolling)(worktreeId, cliToolId, instanceId);
             }
@@ -562,6 +601,14 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
         });
         // Broadcast message to WebSocket clients
         (0, ws_server_1.broadcastMessage)('message', { worktreeId, message });
+        // Issue #1790: the agent has just produced a reply, so whatever it was
+        // waiting for is over. Closing the episode here is what makes a *second*
+        // prompt in the same session notify again: without it a wait opened by the
+        // prompt branch above could stay open until a browser next probes the status
+        // API, and every later prompt would be folded into that stale episode and
+        // silently deduped. Nothing to close is a no-op, and no notification is
+        // raised for a closing edge.
+        (0, waiting_episode_state_1.observeWaitingEdge)({ worktreeId, cliToolId, instanceId, waiting: false });
         // Web Push fan-out (Issue #1125): session completed (running → idle).
         // Fire-and-forget — push is advisory and must never block/break the poller.
         void (0, push_1.notifyPushSubscribers)({

package/dist/server/src/lib/push/escalation-settings.js

@@ -0,0 +1,114 @@
+"use strict";
+/**
+ * The "still waiting" reminder setting (Issue #1790).
+ *
+ * A wait that nobody answers is the case push notifications exist for, and one
+ * notification is easy to miss — so after a threshold the server sends exactly
+ * one more. How long to wait, and whether to do it at all, is a user decision,
+ * and it is a *server-side* one: the check runs in the background with no
+ * request and no browser attached, so it cannot read a device's localStorage the
+ * way #1788's in-app toggle does. It is therefore stored once for the install
+ * and applies to every subscribed device.
+ *
+ * ## Why the SQL lives here
+ *
+ * `app_settings` (migration v27) is the generic key-value store this rides on,
+ * so no migration is added. Its typed helpers live in `db/app-settings-db`, but
+ * both existing ones are `string[]`-shaped and this value is an object with two
+ * fields of different types; a third helper there would be a fourth reader of
+ * the same table with no shared logic to gain. Keeping the accessor beside its
+ * only consumer also keeps the defaults — which the escalation tick applies on
+ * every failure path — in one file.
+ *
+ * Every read is total: a missing row, malformed JSON, an out-of-range threshold
+ * or an unopenable database all resolve to {@link DEFAULT_ESCALATION_SETTINGS}
+ * rather than throwing. The caller is a background timer whose failure mode
+ * must be "no reminder", never "the server logs an exception every minute".
+ *
+ * @module lib/push/escalation-settings
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_ESCALATION_THRESHOLD_MINUTES = exports.MIN_ESCALATION_THRESHOLD_MINUTES = exports.ESCALATION_THRESHOLD_CHOICES = exports.DEFAULT_ESCALATION_SETTINGS = exports.ESCALATION_SETTINGS_KEY = void 0;
+exports.normalizeEscalationSettings = normalizeEscalationSettings;
+exports.getPushEscalationSettings = getPushEscalationSettings;
+exports.setPushEscalationSettings = setPushEscalationSettings;
+const db_instance_1 = require("../../lib/db/db-instance");
+const logger_1 = require("../../lib/logger");
+const logger = (0, logger_1.createLogger)('push/escalation-settings');
+/** `app_settings.key` this setting is stored under. */
+exports.ESCALATION_SETTINGS_KEY = 'push_escalation';
+/**
+ * On by default at ten minutes, per the Issue.
+ *
+ * Defaulting to *on* is the same call #1788 made for the in-app toast: a user
+ * who never opened the settings screen is the one most likely to walk away from
+ * a waiting agent, and the cost of being wrong is one extra notification per
+ * unanswered wait — bounded, because there is only ever one.
+ */
+exports.DEFAULT_ESCALATION_SETTINGS = {
+    enabled: true,
+    thresholdMinutes: 10,
+};
+/** The thresholds the settings UI offers, in minutes. */
+exports.ESCALATION_THRESHOLD_CHOICES = [5, 10, 30, 60];
+/** Guard rails for a hand-written value: at least a minute, at most a day. */
+exports.MIN_ESCALATION_THRESHOLD_MINUTES = 1;
+exports.MAX_ESCALATION_THRESHOLD_MINUTES = 1440;
+/**
+ * Narrow arbitrary input to a usable setting, filling each field independently.
+ *
+ * Field-by-field rather than all-or-nothing so that a bad threshold does not
+ * silently switch the reminder back on (or off): the half the user did set is
+ * the half that is honoured.
+ */
+function normalizeEscalationSettings(value) {
+    if (typeof value !== 'object' || value === null)
+        return { ...exports.DEFAULT_ESCALATION_SETTINGS };
+    const record = value;
+    const enabled = typeof record.enabled === 'boolean' ? record.enabled : exports.DEFAULT_ESCALATION_SETTINGS.enabled;
+    const raw = record.thresholdMinutes;
+    const thresholdMinutes = typeof raw === 'number' &&
+        Number.isFinite(raw) &&
+        raw >= exports.MIN_ESCALATION_THRESHOLD_MINUTES &&
+        raw <= exports.MAX_ESCALATION_THRESHOLD_MINUTES
+        ? Math.round(raw)
+        : exports.DEFAULT_ESCALATION_SETTINGS.thresholdMinutes;
+    return { enabled, thresholdMinutes };
+}
+/** Read the setting. Never throws — see the module docblock. */
+function getPushEscalationSettings() {
+    try {
+        const row = (0, db_instance_1.getDbInstance)()
+            .prepare('SELECT value FROM app_settings WHERE key = ?')
+            .get(exports.ESCALATION_SETTINGS_KEY);
+        if (!row)
+            return { ...exports.DEFAULT_ESCALATION_SETTINGS };
+        return normalizeEscalationSettings(JSON.parse(row.value));
+    }
+    catch (error) {
+        logger.warn('escalation-settings-read-failed', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return { ...exports.DEFAULT_ESCALATION_SETTINGS };
+    }
+}
+/**
+ * Persist the setting, normalizing first so a malformed request cannot store a
+ * value later reads would have to reject anyway.
+ *
+ * @returns What was actually written.
+ */
+function setPushEscalationSettings(value) {
+    const settings = normalizeEscalationSettings(value);
+    const now = Date.now();
+    (0, db_instance_1.getDbInstance)()
+        .prepare(`
+      INSERT INTO app_settings (key, value, created_at, updated_at)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(key) DO UPDATE SET
+        value = excluded.value,
+        updated_at = excluded.updated_at
+    `)
+        .run(exports.ESCALATION_SETTINGS_KEY, JSON.stringify(settings), now, now);
+    return settings;
+}