commandmate 0.47.2 → 0.48.0

package/dist/server/src/lib/push/waiting-push-notifier.js

@@ -22,8 +22,10 @@
  * ## The poller still notifies, and that is deliberate
  *
  * Contrary to the Issue's premise, the edge is *not* observed by a background
- * process: `observeWaitingEdge`'s only caller is `worktree-status-helper`, on
- * the worktree list / detail API probe. So the edge fires when a client is
+ * process: when #1790 was written, `observeWaitingEdge`'s only caller was
+ * `worktree-status-helper`, on the worktree list / detail API probe (Issue
+ * #3798 added the agent's own turn transitions as closers, not as openers). So
+ * the edge fires when a client is
  * looking, and moving push onto it *alone* would have swapped one blind spot
  * (no poller) for a worse one (nobody has the app open — the very situation a
  * phone notification is for). The poller therefore keeps its call, and
@@ -50,6 +52,30 @@
  * under whatever the episode is called at that point. One notification either
  * way — no correction push, and nothing at all if the wait ended meanwhile.
  *
+ * ## Which wait is which (Issue #3798)
+ *
+ * A wait is its episode's id, not its `since`: two waits can share a `since`,
+ * and the episode store can put a new wait in place of an old one in one step
+ * (`replaced`). So this subscribes with `onWaitingEpisodeTransition`, which
+ * says which of the three happened, and every re-read of the store — the end of
+ * a classification hold, the end of an Auto-Yes hold, the reminder — compares
+ * the id it reads with `getWaitingEpisodeRecord`. A replacement drops the old
+ * wait's timers and hold and starts the new wait's from scratch, and sends no
+ * resolution: nobody stopped waiting. A pending wait that came without an id
+ * (a test driving {@link handleWaitingTransition} with the #1786 shape) is
+ * compared by `since`, as before.
+ *
+ * A wait the Auto-Yes poller answered and has not yet seen gone is asked
+ * about again, a grace apart, for as long as it lasts (the gate's
+ * `auto-yes-answered`): it notifies only once it turns into a screen a person
+ * drives, and a replacement brings an edge of its own.
+ *
+ * A producer that fans out for the wait it is opening (the response poller,
+ * with the prompt's question to quote) commits the episode inside
+ * {@link fanOutAfterCommit}: the edge's gate runs after the producer's
+ * fan-out, so both name the episode the store just gave the wait and the
+ * producer's notification is the one the episode dedup lets through.
+ *
  * Everything here is advisory: a failure must not disturb the status read that
  * observed the edge (`emit` contains listener throws) nor the poller.
  *
@@ -57,6 +83,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CLASSIFICATION_GRACE_MS = exports.ESCALATION_TICK_MS = void 0;
+exports.fanOutAfterCommit = fanOutAfterCommit;
 exports.handleWaitingTransition = handleWaitingTransition;
 exports.runEscalationTick = runEscalationTick;
 exports.startWaitingPushNotifier = startWaitingPushNotifier;
@@ -100,6 +127,17 @@ exports.ESCALATION_TICK_MS = 60_000;
  * still notify on the edge itself.
  */
 exports.CLASSIFICATION_GRACE_MS = 8_000;
+/**
+ * The open episode, when it is still `wait` (Issue #3798): the same id, or —
+ * for a wait that came without one — the same `since`. Null when the wait is
+ * over or another one is open.
+ */
+function currentEpisodeOf(wait) {
+    const episode = (0, waiting_episode_state_1.getWaitingEpisodeRecord)(wait.worktreeId, wait.cliToolId, wait.instanceId);
+    if (episode === null)
+        return null;
+    return (0, prompt_push_gate_1.isSameWait)(episode, wait) ? episode : null;
+}
 const pending = (0, global_state_1.getOrInitGlobal)('__waitingPushPending', () => new Map());
 /** Composite key -> the timer holding that wait's first notification (#2156). */
 const graceTimers = (0, global_state_1.getOrInitGlobal)('__waitingPushGraceTimers', () => new Map());
@@ -109,6 +147,43 @@ const graceTimers = (0, global_state_1.getOrInitGlobal)('__waitingPushGraceTimer
  * that one is the classification hold of #2156, this one the Auto-Yes hold.
  */
 const answerGraceTimers = (0, global_state_1.getOrInitGlobal)('__waitingPushAnswerGraceTimers', () => new Map());
+/**
+ * Composite key -> the edge gates held back while a producer commits the
+ * episode and fans out for it ({@link fanOutAfterCommit}, Issue #3798).
+ */
+const deferredGates = (0, global_state_1.getOrInitGlobal)('__waitingPushDeferredGates', () => new Map());
+/**
+ * Commit a waiting episode and fan out for it, in that order, with the gate
+ * the episode's own edge runs held back until the fan-out is done (Issue
+ * #3798). The producer then names the episode id the commit just created —
+ * to the gate and to the fan-out — and its notification, carrying what only
+ * the producer has (the prompt's question), claims the episode dedup before
+ * the edge's id-named one asks for the same episode. All synchronous: the
+ * held gates run before this returns, whatever the fan-out threw.
+ *
+ * @param commit - The store write; its edge reaches this module during it
+ * @param fanOut - Given what `commit` returned
+ * @returns What `commit` returned
+ */
+function fanOutAfterCommit(parts, commit, fanOut) {
+    const key = (0, auto_yes_state_1.buildCompositeKey)(parts.worktreeId, parts.cliToolId, parts.instanceId);
+    const outermost = !deferredGates.has(key);
+    if (outermost)
+        deferredGates.set(key, []);
+    try {
+        const committed = commit();
+        fanOut(committed);
+        return committed;
+    }
+    finally {
+        if (outermost) {
+            const held = deferredGates.get(key) ?? [];
+            deferredGates.delete(key);
+            for (const run of held)
+                run();
+        }
+    }
+}
 /**
  * The worktree's display name, for the notification title.
  *
@@ -136,6 +211,7 @@ async function sendWaitingPush(wait, escalated, now) {
             instanceId,
             waitingKind: wait.kind,
             waitingSince: wait.since,
+            waitingEpisodeId: wait.episodeId,
             escalated,
         }, 
         // The deciding tick's clock, not a fresh reading: the reminder's body
@@ -189,6 +265,7 @@ function gateAndSend(wait, now, recheck = false) {
         cliToolId: wait.cliToolId,
         instanceId: wait.instanceId,
         waitingSince: wait.since,
+        waitingEpisodeId: wait.episodeId,
         now,
     }, { recheck });
     if (decision.suppress) {
@@ -197,6 +274,10 @@ function gateAndSend(wait, now, recheck = false) {
         // by then and nothing is sent.
         if (decision.reason === 'auto-yes-answering')
             holdForAutoYesAnswer(wait, now);
+        // Issue #3798: answered, and not yet seen gone — ask again a grace later,
+        // so the screen a person drives that may follow still notifies.
+        else if (decision.reason === 'auto-yes-answered')
+            holdForAutoYesAnswer(wait, now, prompt_push_gate_1.AUTO_YES_ANSWER_GRACE_MS);
         return;
     }
     void sendWaitingPush(wait, false, now);
@@ -207,21 +288,29 @@ function gateAndSend(wait, now, recheck = false) {
  * answered — a screen the poller cannot read and records nothing about — stayed
  * silent until the escalation reminder, ten minutes later.
  */
-function holdForAutoYesAnswer(wait, now) {
+function holdForAutoYesAnswer(wait, now, afterMs) {
     const key = (0, auto_yes_state_1.buildCompositeKey)(wait.worktreeId, wait.cliToolId, wait.instanceId);
     const existing = answerGraceTimers.get(key);
     if (existing !== undefined)
         clearTimeout(existing);
     // From the gate's own origin, not `since` (Issue #3757 review), and past the
-    // poller's session-wait tick (Issue #3791). Capped at the grace, so a clock
+    // poller's session-wait tick or the duplicate guard's retry it reserved (Issue #3791). Capped at the grace, so a clock
     // that went backwards cannot arm an overflowing timer, and a longer hold is
     // asked about again every grace: a poller stopped meanwhile ends it then
     // rather than at a tick that will not come.
-    const holdEndsAt = (0, prompt_push_gate_1.autoYesHoldEndsAt)({ worktreeId: wait.worktreeId, cliToolId: wait.cliToolId, instanceId: wait.instanceId, waitingSince: wait.since }, now);
-    const delay = Math.min(prompt_push_gate_1.AUTO_YES_ANSWER_GRACE_MS, Math.max(0, holdEndsAt - now));
+    const holdEndsAt = (0, prompt_push_gate_1.autoYesHoldEndsAt)({
+        worktreeId: wait.worktreeId,
+        cliToolId: wait.cliToolId,
+        instanceId: wait.instanceId,
+        waitingSince: wait.since,
+        waitingEpisodeId: wait.episodeId,
+    }, now);
+    // Issue #3798: an answered wait whose hold is over is asked about again
+    // `afterMs` later; the hold's end is already behind it.
+    const delay = afterMs ?? Math.min(prompt_push_gate_1.AUTO_YES_ANSWER_GRACE_MS, Math.max(0, holdEndsAt - now));
     const timer = setTimeout(() => {
         answerGraceTimers.delete(key);
-        releaseAutoYesHold(key, wait.since);
+        releaseAutoYesHold(key, wait);
     }, delay);
     // Never hold the process open for it, as with the other timers here.
     timer.unref?.();
@@ -231,15 +320,15 @@ function holdForAutoYesAnswer(wait, now) {
  * The Auto-Yes hold ended: notify unless the wait is over or is another one
  * (Issue #3757). Read from the episode store, as {@link releaseHeldWait} does.
  */
-function releaseAutoYesHold(key, since) {
+function releaseAutoYesHold(key, wait) {
     const held = pending.get(key);
-    if (held === undefined || held.since !== since)
+    if (held === undefined || !(0, prompt_push_gate_1.isSameWait)(held, wait))
         return;
-    const episode = (0, waiting_episode_state_1.getWaitingEpisode)(held.worktreeId, held.cliToolId, held.instanceId);
-    if (episode === null || episode.since !== held.since) {
+    const episode = currentEpisodeOf(held);
+    if (episode === null) {
         pending.delete(key);
         // Issue #3776: this episode's hold only — the next one may hold already.
-        (0, prompt_push_gate_1.forgetAutoYesHold)(key, held.since);
+        (0, prompt_push_gate_1.forgetAutoYesHold)(key, { since: held.since, episodeId: held.episodeId });
         stopEscalationTimerIfIdle();
         return;
     }
@@ -264,8 +353,8 @@ function releaseHeldWait(key) {
     // Gone means the closing edge dropped it, or a reminder already claimed it.
     if (held === undefined)
         return;
-    const episode = (0, waiting_episode_state_1.getWaitingEpisode)(held.worktreeId, held.cliToolId, held.instanceId);
-    if (episode === null || episode.since !== held.since) {
+    const episode = currentEpisodeOf(held);
+    if (episode === null) {
         pending.delete(key);
         stopEscalationTimerIfIdle();
         return;
@@ -309,6 +398,7 @@ function handleWaitingTransition(transition) {
     if (!(0, vapid_1.isPushConfigured)())
         return;
     const key = (0, auto_yes_state_1.buildCompositeKey)(transition.worktreeId, transition.cliToolId, transition.instanceId);
+    const cause = 'cause' in transition ? transition.cause : null;
     if (!transition.waiting || transition.since === null) {
         // Issue #2156: a wait still inside its grace is answered, not notified.
         cancelGrace(key);
@@ -335,11 +425,22 @@ function handleWaitingTransition(transition) {
         });
         return;
     }
+    // Issue #3798: a new wait in place of the old one. The old wait's holds and
+    // timers go — it is over — and no resolution is sent: nobody stopped
+    // waiting, and the new wait's card is about to replace the old one anyway.
+    if (cause === 'replaced') {
+        const old = pending.get(key);
+        cancelGrace(key);
+        pending.delete(key);
+        const previousEpisodeId = 'previousEpisodeId' in transition ? transition.previousEpisodeId : null;
+        (0, prompt_push_gate_1.forgetAutoYesHold)(key, { since: old?.since ?? transition.since, episodeId: previousEpisodeId ?? old?.episodeId });
+    }
     const wait = {
         worktreeId: transition.worktreeId,
         cliToolId: transition.cliToolId,
         instanceId: transition.instanceId,
         since: transition.since,
+        episodeId: episodeIdOf(transition),
         kind: transition.kind,
     };
     // Issue #1999: the wait is tracked and the reminder armed either way — only
@@ -362,8 +463,27 @@ function handleWaitingTransition(transition) {
         graceTimers.set(key, timer);
         return;
     }
+    // Issue #3798: a producer is fanning out for this very edge; its gate runs
+    // after that (`fanOutAfterCommit`).
+    const held = deferredGates.get(key);
+    if (held !== undefined) {
+        held.push(() => gateAndSend(wait, transition.at));
+        return;
+    }
     gateAndSend(wait, transition.at);
 }
+/**
+ * The id of the wait an opening edge is about (Issue #3798). The episode edge
+ * carries it; an edge in the #1786 shape (a test calling
+ * {@link handleWaitingTransition} directly) is matched to the open episode by
+ * its `since`, read with `getWaitingEpisodeRecord`.
+ */
+function episodeIdOf(transition) {
+    if ('episodeId' in transition)
+        return transition.episodeId;
+    const episode = (0, waiting_episode_state_1.getWaitingEpisodeRecord)(transition.worktreeId, transition.cliToolId, transition.instanceId);
+    return episode !== null && episode.since === transition.since ? episode.episodeId : null;
+}
 /**
  * Re-notify every wait that has outlived the threshold, once each.
  *
@@ -381,8 +501,8 @@ function runEscalationTick(now = Date.now()) {
         // still going: it is written by the status probe, so an answer given in
         // another tab — or a wait whose closing edge this module never saw — is
         // caught here even when `pending` still lists it.
-        const episode = (0, waiting_episode_state_1.getWaitingEpisode)(wait.worktreeId, wait.cliToolId, wait.instanceId);
-        if (episode === null || episode.since !== wait.since) {
+        const episode = currentEpisodeOf(wait);
+        if (episode === null) {
             pending.delete(key);
             continue;
         }
@@ -401,6 +521,7 @@ function runEscalationTick(now = Date.now()) {
             cliToolId: wait.cliToolId,
             instanceId: wait.instanceId,
             waitingSince: wait.since,
+            waitingEpisodeId: wait.episodeId,
             escalated: true,
         })) {
             continue;
@@ -424,7 +545,8 @@ function runEscalationTick(now = Date.now()) {
  */
 function startWaitingPushNotifier() {
     stopWaitingPushNotifier();
-    const unsubscribe = (0, waiting_episode_state_1.onWaitingTransition)((transition) => {
+    // Issue #3798: the episode edge, so a replacement is told from a new wait.
+    const unsubscribe = (0, waiting_episode_state_1.onWaitingEpisodeTransition)((transition) => {
         handleWaitingTransition(transition);
     });
     globalThis.__waitingPushUnsubscribe = unsubscribe;

package/dist/server/src/lib/realtime/terminal-broadcast.js

@@ -88,6 +88,17 @@ function snapshotFingerprint(payload) {
         // Issue #3397: so "Auto-Yes sent Enter" (and its `no-effect` follow-up)
         // reaches the push even when the frame did not change.
         payload.autoYes?.lastEnterFallback ?? null,
+        // Issue #3821: so a decision that changed on a screen that did not
+        // (`answering` -> `withheld` on the next tick, say) reaches the push, and
+        // the answer panel opens without waiting for the HTTP poll. State and
+        // reason only: `observedAt` moves on every build. And the confirmation it
+        // is about, so a decision moved to another approval target is pushed too.
+        payload.autoYesDecision?.state ?? null,
+        payload.autoYesDecision?.reason ?? null,
+        payload.autoYesDecision?.confirmation ?? null,
+        // Issue #3863: so a mode change on a screen that did not change reaches the
+        // push too (the answer mode decides whether a question waits for a human).
+        payload.autoYesAnswerMode ?? null,
         payload.isSelectionListActive ?? false,
         payload.isPagerActive ?? false,
         // Issue #2369: in the fingerprint for the same reason `sessionStatus` is —
@@ -156,6 +167,11 @@ function emitTerminalSnapshot(worktreeId, cliToolId, payload, instanceId) {
         // Issue #3397: straight through, like `promptAnswerable` — undefined (and so
         // off the wire) when the payload carries no `autoYes`.
         autoYesEnterFallback: payload.autoYes?.lastEnterFallback,
+        // Issue #3821: straight through as well — absent when the session is not
+        // running (the payload carries none then).
+        autoYesDecision: payload.autoYesDecision,
+        // Issue #3863: straight through — the key is absent while Auto-Yes is off.
+        ...(payload.autoYesAnswerMode !== undefined ? { autoYesAnswerMode: payload.autoYesAnswerMode } : {}),
         isSelectionListActive: payload.isSelectionListActive ?? false,
         isPagerActive: payload.isPagerActive ?? false,
         isDismissablePanelActive: payload.isDismissablePanelActive ?? false,

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

@@ -60,6 +60,11 @@ const agent_event_dedup_1 = require("../../lib/session/agent-event-dedup");
 const agent_event_model_1 = require("../../lib/session/agent-event-model");
 const provisional_turn_1 = require("../../lib/session/provisional-turn");
 const agent_event_turn_1 = require("../../lib/session/agent-event-turn");
+// Issue #3798: the waiting episode follows the turn in the same synchronous
+// step. Imported for its effect too — it registers the binding resolver the
+// episode store uses — so every bundle that records an event or reads a
+// status (both reach this module) has it.
+const waiting_episode_binding_1 = require("../../lib/session/waiting-episode-binding");
 const agent_event_structured_state_1 = require("../../lib/session/agent-event-structured-state");
 const agent_event_awaiting_instruction_1 = require("../../lib/session/agent-event-awaiting-instruction");
 const agent_event_ask_user_question_1 = require("../../lib/session/agent-event-ask-user-question");
@@ -219,6 +224,7 @@ function recordAgentEvent(worktreeId, cliToolId, instanceId, record, options = {
         return { recorded: false, skipped: 'late-session-start' };
     }
     lastAgentEvent.set(key, record);
+    const outcomes = [];
     if (record.event === 'session_start') {
         // Issue #2357: a new agent process, whatever model it names first is its
         // STARTING model — recorded below, announced to nobody. Dropped before the
@@ -246,12 +252,17 @@ function recordAgentEvent(worktreeId, cliToolId, instanceId, record, options = {
         // here rather than inside the transition below so the two paths into a new
         // generation — this one and `beginAgentEventGeneration` — close the turn in
         // exactly one place.
-        (0, agent_event_turn_1.fenceTurnForNewGeneration)(key, record.at);
+        outcomes.push((0, agent_event_turn_1.fenceTurnForNewGeneration)(key, record.at, 'session-start'));
     }
     // Issue #1930: after the generation is settled, so a turn opened by this
     // event belongs to the generation the event itself opened.
-    (0, agent_event_turn_1.applyTurnTransition)(key, record);
+    outcomes.push((0, agent_event_turn_1.applyTurnTransition)(key, record));
     (0, agent_event_awaiting_instruction_1.applyAwaitingInstructionTransition)(key, record);
+    // Issue #3798: last, once every map above says what this delivery did, so
+    // an edge's listeners read the state the delivery left. The stop is recorded,
+    // the turn ended and its wait closed in this one synchronous step; whatever
+    // the caller awaits next (`applyAgentStopEvent`) never touches the episode.
+    (0, waiting_episode_binding_1.applyTurnOutcomesToEpisode)({ worktreeId, cliToolId, instanceId }, outcomes);
     return { recorded: true };
 }
 /**
@@ -287,7 +298,7 @@ function beginAgentEventGeneration(worktreeId, cliToolId, instanceId, at = Date.
     // `closedBy: 'generation'`, so `capture --json` can say why it ended instead
     // of going quiet. The dialogs #1725 kept in a map of their own live on that
     // record now, which is what makes this one call retire both.
-    (0, agent_event_turn_1.fenceTurnForNewGeneration)(key, at);
+    const fenced = (0, agent_event_turn_1.fenceTurnForNewGeneration)(key, at, 'process-start');
     // Same reasoning for the question that dialog was asking (Issue #1726).
     agent_event_ask_user_question_1.askUserQuestion.delete(key);
     // And for "waiting for your input" (Issue #1786): a new process has not asked
@@ -317,6 +328,8 @@ function beginAgentEventGeneration(worktreeId, cliToolId, instanceId, at = Date.
     // has just been replaced. Unlike the time-window keys, they never expire on
     // their own, so a generation is the only thing that retires them.
     agent_event_dedup_1.recentEventIdentities.delete(key);
+    // Issue #3798: and the wait the replaced process was in (design T19).
+    (0, waiting_episode_binding_1.applyTurnOutcomesToEpisode)({ worktreeId, cliToolId, instanceId }, [fenced], at);
 }
 /**
  * @returns Epoch ms the current generation began, or null when no generation
@@ -381,7 +394,7 @@ exports.STRUCTURED_PROMPT_PROVISIONAL_MAX_AGE_MS = provisional_turn_1.DIALOG_PEN
  */
 function reportPermissionRequestPending(worktreeId, cliToolId, instanceId, toolName, at = Date.now()) {
     const key = (0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId);
-    (0, agent_event_turn_1.openDecision)(key, (0, agent_event_turn_1.currentGeneration)(key), {
+    const opened = (0, agent_event_turn_1.openDecision)(key, (0, agent_event_turn_1.currentGeneration)(key), {
         source: 'permission-request',
         at,
         message: null,
@@ -396,6 +409,9 @@ function reportPermissionRequestPending(worktreeId, cliToolId, instanceId, toolN
         // is unaffected — that reads `getLastAgentEvent`, which nothing here writes.
         bootstrapDisplay: { event: 'notification', at, detail: 'permission_prompt' },
     });
+    // Issue #3798 (design R3-6): a decision opened outside `recordAgentEvent`
+    // tells the waiting episode itself.
+    (0, waiting_episode_binding_1.applyTurnOutcomesToEpisode)({ worktreeId, cliToolId, instanceId }, [{ kind: 'decision-opened', ...opened }]);
 }
 /**
  * Report that a QUESTION dialog is open, naming the decision it is answered by
@@ -437,7 +453,7 @@ function reportPermissionRequestPending(worktreeId, cliToolId, instanceId, toolN
  */
 function reportQuestionPending(worktreeId, cliToolId, instanceId, input, at = Date.now()) {
     const key = (0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId);
-    (0, agent_event_turn_1.openDecision)(key, (0, agent_event_turn_1.currentGeneration)(key), {
+    const opened = (0, agent_event_turn_1.openDecision)(key, (0, agent_event_turn_1.currentGeneration)(key), {
         source: 'notification',
         at,
         // The question TEXT is not the dialog's `message`: it is published as
@@ -451,6 +467,8 @@ function reportQuestionPending(worktreeId, cliToolId, instanceId, input, at = Da
         decisionId: input.decisionId,
         bootstrapDisplay: { event: 'notification', at, detail: input.detail },
     });
+    // Issue #3798 (design R3-6): as for the forecast above.
+    (0, waiting_episode_binding_1.applyTurnOutcomesToEpisode)({ worktreeId, cliToolId, instanceId }, [{ kind: 'decision-opened', ...opened }]);
 }
 /**
  * The open dialog this instance's structured events imply, or null.
@@ -534,4 +552,6 @@ function clearAgentStopEvents() {
     // listener set is deliberately NOT cleared — a subscription belongs to the
     // process, not to a session, and a suite that armed one expects it to stay.
     agent_event_model_1.modelBaseline.clear();
+    // Issue #3798: and which generation last heard a hook stop.
+    (0, waiting_episode_binding_1.clearWaitingEpisodeBindingState)();
 }