commandmate 0.31.1 → 0.31.3

package/dist/server/src/lib/hooks/sources/claude/model-switch.js

@@ -0,0 +1,169 @@
+"use strict";
+/**
+ * Claude Code's `PostModelSwitch` hook, as CommandMate reads it (Issue #2363).
+ *
+ * #2361 detected a `/model` switch off the pane, because the seven events
+ * CommandMate registered never mentioned it: Claude names its model on
+ * `SessionStart` and on nothing else. The same probe found the build emitting
+ * a pair of dedicated hooks, and this module is the structured half of the
+ * answer — the frame reader stays as the fallback (see
+ * `lib/session/agent-event-state`'s `FRAME_OVERTAKES_HOOK_MODEL_TOOLS`).
+ *
+ * ## Measured on claude 2.1.263 (2026-09-06, isolated `CLAUDE_CONFIG_DIR`)
+ *
+ * Re-taken for this Issue rather than inherited from #2361, whose numbers were
+ * a by-product. Payload, delivered verbatim by a `type: "http"` hook injected
+ * through `--settings` — the same channel every other event here uses:
+ *
+ * ```json
+ * {
+ *   "session_id": "…", "transcript_path": "…", "cwd": "…", "prompt_id": "…",
+ *   "hook_event_name": "PostModelSwitch",
+ *   "from_model": "claude-haiku-4-5-20251001",
+ *   "to_model": "claude-sonnet-5",
+ *   "requested_model": "sonnet",
+ *   "source": "command",
+ *   "context_tokens": 0, "prompt_cache_warm": false, "cache_ttl": "5m",
+ *   "estimated_cache_write_usd": 0, "pricing": "catalog"
+ * }
+ * ```
+ *
+ *  - **`to_model` is the model id in the `SessionStart` spelling** —
+ *    `claude-sonnet-5`, `claude-haiku-4-5-20251001`, `claude-opus-5`,
+ *    `claude-opus-5[1m]` — so the latch in `agent-event-state` compares like
+ *    with like, and the `[1m]` suffix travels with it.
+ *  - **`/fast` is a switch**: ON from Haiku reported `to_model:
+ *    "claude-opus-5[1m]"`, `requested_model: null`, `source: "command"`. That
+ *    is the fix for the spelling drift #2361 refused to read (the confirmation
+ *    line says `Opus 5`, the banner `Opus 5 (1M context)`): the hook spells it
+ *    the one way. `/fast` OFF fires nothing and the model stays on Opus.
+ *  - **`requested_model` is null** for `/model default` (→ `claude-opus-5[1m]`)
+ *    and for `/fast`, and is the user's alias (`sonnet`) otherwise. Never read.
+ *  - **`source`** is `command` for `/model <arg>` and `/fast`, `picker` for the
+ *    interactive list (measured with `s`). The schema also names `sdk`, `auto`
+ *    and `resume`; none were reproducible. Not read.
+ *  - **Nothing fires when the model does not change**: `/model haiku` while on
+ *    Haiku, `/fast` while already on Opus 1M, the picker's `Esc` (`Kept model
+ *    as`), and `/effort` all stay silent. `/clear` emits its usual
+ *    `SessionEnd` + `SessionStart` (no `model` key) and no switch.
+ *  - **There is no `model` key on this event.** The generic `modelFields:
+ *    ['model']` lookup answers null for it, which is why the extraction below
+ *    exists rather than a second entry in that list.
+ *
+ * ## Why `from_model` is never read
+ *
+ * It is the model the session was on BEFORE the switch. Reading it as "the
+ * model" would move the latch backwards on the very event that reports a
+ * forward move. It is also the field the paired `PreModelSwitch` got wrong:
+ * in the probe's second session that hook fired **twice per switch**, and on
+ * `/fast` the second of the two named `from_model: "claude-sonnet-5"` for a
+ * session that was on Haiku (`PostModelSwitch` fired once, and agreed with
+ * the screen, every time).
+ *
+ * ## Why `PreModelSwitch` is not registered
+ *
+ * Three measured reasons. It is a decision hook — its response body can block
+ * or redirect the switch — and the event receiver answers a fixed 202 that
+ * decides nothing, so registering it would put a blocking round-trip (5 s at
+ * worst, on a wedged server) in front of every `/model` for no information.
+ * It fired twice per switch with inconsistent values (above). And its
+ * `to_model` is the request, not the outcome — the second of that pair on
+ * `/model haiku` said `to_model: "claude-sonnet-5"`; `PostModelSwitch` alone
+ * is the event that says what happened. The Issue leaves this to
+ * implementation judgement, and this is it.
+ *
+ * ## Which of the seven words
+ *
+ * `notification`, with a subtype of its own ({@link modelSwitchDetail}). A
+ * model switch is the agent telling the human something and is neither a turn
+ * boundary nor a tool call; `agent-event-state` treats a `notification` whose
+ * subtype it does not recognise as evidence of nothing (no status, no dialog,
+ * no turn), and `status-mapping` answers null for it — measured behaviour, not
+ * a hope. The one thing every event does is run the model latch, and that is
+ * the whole point of delivering this one.
+ *
+ * @module lib/hooks/sources/claude/model-switch
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claudeModelSwitchMapper = exports.MODEL_SWITCH_DETAIL = exports.CLAUDE_PRE_MODEL_SWITCH_EVENT_NAME = exports.CLAUDE_POST_MODEL_SWITCH_EVENT_NAME = void 0;
+exports.modelSwitchDetail = modelSwitchDetail;
+exports.isModelSwitchDetail = isModelSwitchDetail;
+exports.isClaudeModelSwitchPayload = isClaudeModelSwitchPayload;
+exports.extractClaudeSwitchedModel = extractClaudeSwitchedModel;
+const event_mapper_1 = require("../event-mapper");
+/** Claude's own name for the event; the key written into `--settings`. */
+exports.CLAUDE_POST_MODEL_SWITCH_EVENT_NAME = 'PostModelSwitch';
+/**
+ * The paired decision hook, which is deliberately NOT registered — see the
+ * module comment. Named here so the test that pins its absence from the
+ * injected settings spells it the way this module does.
+ */
+exports.CLAUDE_PRE_MODEL_SWITCH_EVENT_NAME = 'PreModelSwitch';
+/**
+ * The subtype a switch is filed under (Issue #2363).
+ *
+ * A word of CommandMate's own, beside Claude's `permission_prompt` /
+ * `idle_prompt` on the same event. Nothing branches on it — the model rides on
+ * the normalised event's `model`, not on the subtype — but two things read it:
+ * `structuredEvents.lastEventDetail` shows it, and the receiver's
+ * de-duplication key carries it. See {@link modelSwitchDetail} for why the
+ * target model is appended.
+ */
+exports.MODEL_SWITCH_DETAIL = 'model_switch';
+/** The payload key that names the model the session is now on. */
+const TO_MODEL_FIELD = 'to_model';
+/**
+ * `model_switch:<to_model>`, or the bare word when the switch names no target.
+ *
+ * The target is part of the subtype because the subtype is part of the
+ * receiver's de-duplication key: `(instance, event, detail, session_id)` within
+ * a 3 s window (`isDuplicateAgentEvent`). With a fixed word, two switches to
+ * DIFFERENT models inside that window — the picker's `s` followed by `/fast`,
+ * a `/model` typed twice to correct itself — would collapse into one and the
+ * second target would be lost until the frame caught up. With the target in
+ * the key, only a second delivery of the SAME switch collapses, which is the
+ * case the window exists for (a user's own `PostModelSwitch` hook is
+ * concatenated with the injected one, and both name the same `to_model`).
+ */
+function modelSwitchDetail(toModel) {
+    return toModel === null ? exports.MODEL_SWITCH_DETAIL : `${exports.MODEL_SWITCH_DETAIL}:${toModel}`;
+}
+/** Whether a recorded `detail` is one this module wrote, target or no target. */
+function isModelSwitchDetail(detail) {
+    return detail === exports.MODEL_SWITCH_DETAIL || (detail?.startsWith(`${exports.MODEL_SWITCH_DETAIL}:`) ?? false);
+}
+/** True for the one native event this module speaks for. */
+function isClaudeModelSwitchPayload(payload) {
+    return (0, event_mapper_1.readStringField)(payload, 'hook_event_name') === exports.CLAUDE_POST_MODEL_SWITCH_EVENT_NAME;
+}
+/**
+ * The rule that maps `PostModelSwitch` onto `notification(model_switch:<to_model>)`.
+ *
+ * Appended after the shared CamelCase table in `./source`, so every spelling
+ * that table already claims keeps its word.
+ */
+const claudeModelSwitchMapper = (nativeEventName, payload) => nativeEventName === exports.CLAUDE_POST_MODEL_SWITCH_EVENT_NAME
+    ? {
+        event: 'notification',
+        detail: modelSwitchDetail((0, event_mapper_1.readStringField)(payload, TO_MODEL_FIELD)),
+    }
+    : null;
+exports.claudeModelSwitchMapper = claudeModelSwitchMapper;
+/**
+ * The model a `PostModelSwitch` reports, or null for any other payload.
+ *
+ * `to_model` and only `to_model`: `from_model` is the value being left behind
+ * and `requested_model` is an alias that is null for `/model default` and
+ * `/fast`. Answers null for a switch that somehow carries no `to_model`, which
+ * the caller (`buildNormalizedEvent`) turns into "this event names no model"
+ * — the latch is left where it was rather than blanked or reversed.
+ *
+ * Declared as the source's `extractModel`, which runs before the flat
+ * `modelFields` lookup; for every other event it answers null and the lookup
+ * proceeds exactly as it did before this Issue.
+ */
+function extractClaudeSwitchedModel(payload) {
+    if (!isClaudeModelSwitchPayload(payload))
+        return null;
+    return (0, event_mapper_1.readStringField)(payload, TO_MODEL_FIELD);
+}

package/dist/server/src/lib/hooks/sources/claude/source.js

@@ -41,6 +41,7 @@ const permission_request_payload_1 = require("../../../../lib/hooks/permission-r
 const define_source_1 = require("../define-source");
 const event_mapper_1 = require("../event-mapper");
 const hook_event_vocabulary_1 = require("../hook-event-vocabulary");
+const model_switch_1 = require("./model-switch");
 const tool_id_1 = require("./tool-id");
 /**
  * The no-decision body, byte for byte what the #1721 spike returned for D5.
@@ -129,7 +130,12 @@ exports.claudeAgentEventSource = (0, define_source_1.definePushHookSource)({
     // word, no predicates — so it is expressed as rules built from the table
     // rather than as a table, and a source that needs conditions (opencode) adds
     // them to the same list.
-    mappers: (0, event_mapper_1.fromNameTable)(hook_event_vocabulary_1.CAMEL_CASE_HOOK_EVENT_NAMES),
+    //
+    // Issue #2363: plus the one spelling that is Claude's alone. `PostModelSwitch`
+    // is filed as `notification(model_switch:<to_model>)` — see `./model-switch`
+    // for the measurement and for why its `Pre` twin is not here. Appended after
+    // the shared table so nothing that table claims changes its word.
+    mappers: [...(0, event_mapper_1.fromNameTable)(hook_event_vocabulary_1.CAMEL_CASE_HOOK_EVENT_NAMES), model_switch_1.claudeModelSwitchMapper],
     nativeEventNameFields: ['hook_event_name'],
     conversationIdFields: hook_event_vocabulary_1.SESSION_ID_FIELDS,
     toolCallIdFields: hook_event_vocabulary_1.TOOL_CALL_ID_FIELDS,
@@ -140,6 +146,13 @@ exports.claudeAgentEventSource = (0, define_source_1.definePushHookSource)({
     // does that. The value arrives with its own suffix (`claude-opus-5[1m]`) and
     // is not parsed here: a display string the tool chose is the tool's to spell.
     modelFields: ['model'],
+    // Issue #2363. The second and only other event that names a model, and it
+    // names it under a different key: `PostModelSwitch` carries `to_model` (the
+    // model the session is now on) and no `model` at all. Read there, and only
+    // there — `from_model` is the value being left behind and must never reach
+    // the latch. `extractModel` runs before `modelFields`, and answers null for
+    // every other event so the flat lookup above is unchanged for them.
+    extractModel: model_switch_1.extractClaudeSwitchedModel,
     // S2.
     extractDetail: hook_event_vocabulary_1.extractSnakeCaseEventDetail,
     // S7. Both parsers are strict and answer null for anything they cannot vouch

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

@@ -11,6 +11,7 @@ const db_instance_1 = require("../../lib/db/db-instance");
 const db_1 = require("../../lib/db");
 const ws_server_1 = require("../../lib/ws-server");
 const prompt_detector_1 = require("../../lib/detection/prompt-detector");
+const dialog_1 = require("../../lib/detection/tools/antigravity/dialog");
 const conversation_logger_1 = require("../../lib/conversation-logger");
 const types_1 = require("../../lib/cli-tools/types");
 const claude_output_1 = require("../../lib/claude-output");
@@ -190,8 +191,23 @@ function buildPromptExtractionResult(lines, lastCapturedLine, totalLines, buffer
  * @returns PromptDetectionResult with isPrompt, promptData, and cleanContent
  */
 function detectPromptWithOptions(output, cliToolId) {
+    const clean = (0, cli_patterns_1.stripBoxDrawing)((0, cli_patterns_1.stripAnsi)(output));
+    // Issue #2364: agy's `↑/↓ Navigate` dialogs are read by agy's own reader
+    // before the generic pass, on the same spelling `tools/antigravity/detect.ts`
+    // reads them on. The generic multiple-choice parser takes one row per option
+    // and agy wraps a long command across several rows of one label, so without
+    // this the poller stored nothing for the frame the status API published as a
+    // prompt — and, on the file-creation menu, stored a question with the diff
+    // preview joined into it. One reader for both producers is what makes the
+    // stored `prompt` row, the push notification's excerpt and `/current-output`
+    // agree about one screen.
+    if (cliToolId === 'antigravity') {
+        const dialog = (0, dialog_1.detectAntigravityNumberedDialogPrompt)(clean);
+        if (dialog !== null)
+            return dialog;
+    }
     const promptOptions = (0, cli_patterns_1.buildDetectPromptOptions)(cliToolId);
-    return (0, prompt_detector_1.detectPrompt)((0, cli_patterns_1.stripBoxDrawing)((0, cli_patterns_1.stripAnsi)(output)), promptOptions);
+    return (0, prompt_detector_1.detectPrompt)(clean, promptOptions);
 }
 // ============================================================================
 // extractResponse (internal)

package/dist/server/src/lib/polling/response-poller-core.js

@@ -61,7 +61,14 @@ const coordinator = globalThis.__responsePollerCoordinator ??
         pendingRestart: new Map(),
         ownerStorage: new async_hooks_1.AsyncLocalStorage(),
         generationCounter: 0,
+        pausedOnPrompt: new Set(),
     });
+// The coordinator object outlives a module reload (that is the point of putting
+// it on `globalThis`), so a field added after the object was first built has to
+// be filled in on an object an older evaluation created — `next dev` keeps
+// `globalThis` across HMR, and a poller started before the reload would
+// otherwise crash the first tick after it.
+coordinator.pausedOnPrompt ??= new Set();
 /**
  * Active pollers map: "worktreeId:instanceId" -> NodeJS.Timeout
  *
@@ -107,10 +114,23 @@ function takeOwnership(pollerKey) {
         generation: ++coordinator.generationCounter,
         superseded: false,
         stopped: false,
+        selfStopped: false,
     };
     coordinator.owners.set(pollerKey, owner);
     return owner;
 }
+/**
+ * The tools whose chain ends the moment a reply is saved (opencode, copilot).
+ *
+ * `checkForResponse()` stops the poller on exactly two "something was recorded"
+ * paths, and they are split by this predicate: a full-screen TUI's chain stops
+ * AFTER ITS REPLY, every other tool's chain stops ON A PROMPT and expects
+ * `/respond` to start it again. The same two tools are the ones that need the
+ * Layer-2 accumulator, so this is the single place the pair is spelled out.
+ */
+function isFullScreenTui(cliToolId) {
+    return cliToolId === 'opencode' || cliToolId === 'copilot';
+}
 // ============================================================================
 // Polling lifecycle (public API)
 // ============================================================================
@@ -122,6 +142,17 @@ function takeOwnership(pollerKey) {
  * `checkForResponse()` does **not** run the two side by side — the restart is
  * handed to that tick's epilogue and applied when it settles.
  *
+ * Issue #2230: two different callers reach this function, and they mean two
+ * different things. `sendUserMessage` starts a NEW TURN — the previous chain is
+ * still ticking over the finished screen, and the restart drops its response
+ * hash so an identical reply in the new turn is still recorded (#1268).
+ * `/respond`, `/prompt-response` and the Auto-Yes poller RESUME the turn the
+ * chain paused on when it recorded a prompt — the chain has already stopped
+ * itself, the screen may be exactly the finished turn the prompt was drawn
+ * over, and the hash is kept so that screen is not saved a second time. The
+ * two are told apart by the state the previous chain left behind
+ * ({@link PollerCoordinator.pausedOnPrompt}), not by who is calling.
+ *
  * @param worktreeId - Worktree ID
  * @param cliToolId - CLI tool ID (claude, codex, gemini)
  * @param instanceId - Optional agent instance ID (defaults to primary)
@@ -151,8 +182,22 @@ function startPolling(worktreeId, cliToolId, instanceId) {
         });
         coordinator.running.delete(pollerKey);
     }
-    // Stop existing poller if any
-    stopPolling(worktreeId, cliToolId, instanceId);
+    restartChain(pollerKey, target);
+}
+/**
+ * Retire whatever chain holds `pollerKey` and start a fresh one for `target`.
+ *
+ * Shared by the direct path of {@link startPolling} and the queued restart a
+ * tick applies in its epilogue, so both make the same decision about the
+ * response hash (Issue #2230): kept when the previous chain paused itself on a
+ * prompt and this is the resume, dropped otherwise.
+ */
+function restartChain(pollerKey, target) {
+    const resume = coordinator.pausedOnPrompt.has(pollerKey);
+    stopPollingByKey(pollerKey, { resume });
+    if (resume) {
+        logger.info('poller:resumed-after-prompt', { pollerKey });
+    }
     beginPolling(target);
 }
 /** Seed a fresh polling cycle (start time, TUI accumulator) and schedule its first tick. */
@@ -161,7 +206,7 @@ function beginPolling(target) {
     // Record start time
     coordinator.pollingStartTimes.set(pollerKey, Date.now());
     // Initialize TUI accumulator for full-screen TUI tools (Layer 2 safety net)
-    if (target.cliToolId === 'opencode' || target.cliToolId === 'copilot') {
+    if (isFullScreenTui(target.cliToolId)) {
         (0, tui_accumulator_1.initTuiAccumulator)(pollerKey);
     }
     // Start polling with setTimeout chain to prevent race conditions
@@ -212,12 +257,18 @@ async function runPollTick(target, owner) {
             return;
         }
         // Check for response
+        let recorded = false;
         try {
-            await coordinator.ownerStorage.run(owner, () => (0, response_checker_1.checkForResponse)(target.worktreeId, target.cliToolId, target.instanceId));
+            recorded = await coordinator.ownerStorage.run(owner, () => (0, response_checker_1.checkForResponse)(target.worktreeId, target.cliToolId, target.instanceId));
         }
         catch (error) {
             logger.error('error:', { error: error instanceof Error ? error.message : String(error) });
         }
+        // Issue #2230: the chain stopped itself inside that call. Now that its
+        // verdict is known, decide whether the stop ended the turn or paused it.
+        if (owner.selfStopped) {
+            settleSelfStop(owner, target, recorded);
+        }
         // Issue #1120: push the current terminal snapshot to WS subscribers so the
         // output streams during generation. No-op (and no tmux capture) when nobody
         // is subscribed to the worktree room. Best-effort; polling is the fallback.
@@ -244,16 +295,63 @@ async function runPollTick(target, owner) {
         const pending = coordinator.pendingRestart.get(pollerKey);
         if (pending) {
             coordinator.pendingRestart.delete(pollerKey);
-            stopPollingByKey(pollerKey);
-            beginPolling(pending);
+            restartChain(pollerKey, pending);
         }
     }
 }
+/**
+ * Finish a stop that `checkForResponse()` raised from inside its own tick
+ * (Issue #2230).
+ *
+ * `checkForResponse()` ends its chain on four paths, and `stopPollingByKey()`
+ * cannot tell them apart while the call is still on the stack — so it leaves
+ * the response hash alone and this runs once the verdict is in:
+ *
+ * - **recorded, not a full-screen TUI** — the prompt path. The turn is NOT
+ *   over: the agent is waiting for an answer, and the screen under the dialog
+ *   is very often the previous reply, already saved. The hash stays and the
+ *   key is marked paused, so the `/respond` (or Auto-Yes) restart that follows
+ *   resumes the cycle instead of opening one over the same screen. Measured
+ *   live on 2026-09-01: claude drew `Teach auto mode about your environment?`
+ *   AFTER a finished turn, and answering it re-saved the reply.
+ * - **recorded, full-screen TUI** — the reply itself was just saved and the
+ *   chain is done. The cycle ends here exactly as before.
+ * - **nothing recorded** — worktree gone or session not running. There is no
+ *   turn left to protect, and a hash kept here would suppress the first reply
+ *   of the session that replaces it.
+ *
+ * The prompt hash is NOT kept in any of these. If the answer did not take and
+ * the same dialog is still up on the first resumed tick, the operator has to
+ * get a new card rather than silence.
+ */
+function settleSelfStop(owner, target, recorded) {
+    if (recorded && !isFullScreenTui(target.cliToolId)) {
+        coordinator.pausedOnPrompt.add(owner.pollerKey);
+        logger.info('poller:paused-on-prompt', {
+            pollerKey: owner.pollerKey,
+            generation: owner.generation,
+        });
+        return;
+    }
+    (0, response_dedup_1.clearResponseHashCache)(owner.pollerKey);
+}
 /**
  * Stop the poller identified by an already-computed poller key.
  * Shared by stopPolling() and stopAllPolling() so cleanup logic stays in one place.
+ *
+ * Issue #2230: this is where the per-turn dedup caches end, and the response
+ * hash is the one whose ending has to be timed. It is dropped here for an
+ * explicit stop (a route, `session-cleanup`, `kill-session`, the 30-minute
+ * budget) and for the restart that opens a new turn. It is **kept** in two
+ * cases: `resume` — the restart is picking up a chain that paused itself on a
+ * prompt — and a stop raised by the chain's own tick, whose meaning is settled
+ * by {@link settleSelfStop} once `checkForResponse()` has returned. The prompt
+ * hash and the TUI accumulator are dropped unconditionally, as before.
+ *
+ * @param pollerKey - Poller key ("worktreeId:instanceId")
+ * @param options.resume - This stop precedes a restart of a paused chain.
  */
-function stopPollingByKey(pollerKey) {
+function stopPollingByKey(pollerKey, options = {}) {
     // Issue #2223: a tick that has been superseded still runs to completion, and
     // `checkForResponse()` ends the turn with `stopPolling()` on four paths
     // (worktree gone, session not running, prompt detected, TUI reply saved).
@@ -268,13 +366,20 @@ function stopPollingByKey(pollerKey) {
         return;
     }
     const owner = coordinator.owners.get(pollerKey);
+    // The live owner stopping itself from inside its own tick. Identity, not key
+    // equality: a stale generation with the same key was turned away above.
+    const selfStop = owner !== undefined && caller === owner;
     if (owner) {
         owner.stopped = true;
+        owner.selfStopped = selfStop;
         coordinator.owners.delete(pollerKey);
     }
     // A restart queued behind an in-flight tick is cancelled by an explicit stop:
     // "start then stop" must leave the session stopped.
     coordinator.pendingRestart.delete(pollerKey);
+    // Whatever this stop is, the pause it may be ending is over: a resume consumes
+    // it, an explicit stop cancels it.
+    coordinator.pausedOnPrompt.delete(pollerKey);
     const timerId = coordinator.activePollers.get(pollerKey);
     if (timerId) {
         clearTimeout(timerId);
@@ -287,7 +392,12 @@ function stopPollingByKey(pollerKey) {
     (0, prompt_dedup_1.clearPromptHashCache)(pollerKey);
     // Issue #1268: Clear response hash cache too, so the next turn can save a
     // response even when its content is identical to the previous turn's.
-    (0, response_dedup_1.clearResponseHashCache)(pollerKey);
+    //
+    // Issue #2230: unless this turn is not actually over. A self-stop is settled
+    // by the tick once its verdict is known; a resume is continuing a paused turn.
+    if (!selfStop && !options.resume) {
+        (0, response_dedup_1.clearResponseHashCache)(pollerKey);
+    }
 }
 /**
  * Stop polling for a worktree and CLI tool / instance combination
@@ -312,11 +422,15 @@ function stopAllPolling() {
     const keys = new Set([
         ...Array.from(coordinator.activePollers.keys()),
         ...Array.from(coordinator.owners.keys()),
+        // Issue #2230: a paused chain has no timer and no owner, but it is still
+        // holding a response hash for the turn it paused on.
+        ...Array.from(coordinator.pausedOnPrompt),
     ]);
     for (const pollerKey of keys) {
         stopPollingByKey(pollerKey);
     }
     coordinator.pendingRestart.clear();
+    coordinator.pausedOnPrompt.clear();
 }
 /**
  * Get list of active pollers
@@ -448,10 +562,30 @@ function migrateResponsePollerWorktreeIds(renames, resolveCliToolId) {
     for (const move of moves) {
         const startedAt = carried.get(move.newKey)?.startedAt;
         exports.pollingStartTimes.set(move.newKey, startedAt ?? Date.now());
-        if (move.cliToolId === 'opencode' || move.cliToolId === 'copilot') {
+        if (isFullScreenTui(move.cliToolId)) {
             (0, tui_accumulator_1.initTuiAccumulator)(move.newKey);
         }
         scheduleNextResponsePoll(move.newWorktreeId, move.cliToolId, move.instanceId);
     }
+    // Issue #2230: a chain paused on a prompt has no timer, so the loop above
+    // never sees it — but it is holding the response hash for the turn it paused
+    // on, and `/respond` will resume it under the NEW ID. Move the hash and the
+    // pause mark with it; the chain itself stays paused until that resume.
+    const pausedMoves = [];
+    for (const pollerKey of Array.from(coordinator.pausedOnPrompt)) {
+        const parts = splitPollerKey(pollerKey);
+        if (!parts)
+            continue;
+        const newWorktreeId = targets.get(parts.worktreeId);
+        if (!newWorktreeId)
+            continue;
+        pausedMoves.push({ oldKey: pollerKey, newKey: `${newWorktreeId}:${parts.instanceId}` });
+    }
+    for (const move of pausedMoves)
+        coordinator.pausedOnPrompt.delete(move.oldKey);
+    for (const move of pausedMoves) {
+        (0, response_dedup_1.renameResponseHashCacheKey)(move.oldKey, move.newKey);
+        coordinator.pausedOnPrompt.add(move.newKey);
+    }
     return moves;
 }

package/dist/server/src/lib/push/index.js

@@ -2,7 +2,7 @@
 /** Web Push module barrel (Issue #1125). */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.notifyPromptResolved = exports.decidePromptResolution = exports.MAX_ESCALATION_THRESHOLD_MINUTES = exports.MIN_ESCALATION_THRESHOLD_MINUTES = exports.ESCALATION_SETTINGS_KEY = exports.ESCALATION_THRESHOLD_CHOICES = exports.DEFAULT_ESCALATION_SETTINGS = exports.normalizeEscalationSettings = exports.setPushEscalationSettings = exports.getPushEscalationSettings = exports.ESCALATION_TICK_MS = exports.pendingEscalationCount = exports.runEscalationTick = exports.handleWaitingTransition = exports.isWaitingPushNotifierActive = exports.stopWaitingPushNotifier = exports.startWaitingPushNotifier = exports.UPSTREAM_FAULT_COOLDOWN_MS = exports.clearUpstreamFaultEpisodes = exports.observeUpstreamFaultEdge = exports.notifySessionStartFailurePush = exports.notifyUpstreamFaultPush = exports.notifyVerificationFailurePush = exports.isPromptPushSuppressed = exports.decidePromptPush = exports.resetWaitingPushDedup = exports.shouldSendWaitingPush = exports.DEFAULT_DEDUP_WINDOW_MS = exports.resetNotificationDedup = exports.shouldSendNotification = exports.resolvePushLocale = exports.buildExcerpt = exports.buildPushPayload = exports.notifyPushSubscribers = exports.PUSH_DELIVERY_HEALTH_MAX_AGE_MS = exports.PUSH_DELIVERY_HEALTH_KEY_PREFIX = exports.clearAllPushDeliveryHealth = exports.clearPushDeliveryHealth = exports.recordPushDeliveryFailure = exports.getPushDeliveryHealth = exports.VAPID_ENV_KEYS = exports.VAPID_DEFAULT_SUBJECT = exports.extractVapidSubjectHost = exports.classifyVapidSubject = exports.runVapidSelfCheck = exports.formatVapidReportLines = exports.inspectVapidConfig = exports.getVapidPublicKey = exports.isPushConfigured = exports.getVapidConfig = void 0;
-exports.PROMPT_CARD_MAX_AGE_MS = exports.PROMPT_CARD_KEY_PREFIX = exports.promptCardCount = exports.forgetPromptCardMemory = exports.clearAllPromptCards = exports.clearPromptCard = exports.hasPromptCard = exports.markPromptCardShown = exports.MIN_DEVICES_FOR_CROSS_DEVICE_CLEAR = void 0;
+exports.MODEL_CHANGE_TAG_SUFFIX = exports.resolveReadersLocale = exports.buildModelChangedBodies = exports.buildModelChangedSentence = exports.notifyModelChangePush = exports.PROMPT_CARD_MAX_AGE_MS = exports.PROMPT_CARD_KEY_PREFIX = exports.promptCardCount = exports.forgetPromptCardMemory = exports.clearAllPromptCards = exports.clearPromptCard = exports.hasPromptCard = exports.markPromptCardShown = exports.MIN_DEVICES_FOR_CROSS_DEVICE_CLEAR = void 0;
 var vapid_1 = require("./vapid");
 Object.defineProperty(exports, "getVapidConfig", { enumerable: true, get: function () { return vapid_1.getVapidConfig; } });
 Object.defineProperty(exports, "isPushConfigured", { enumerable: true, get: function () { return vapid_1.isPushConfigured; } });
@@ -93,3 +93,15 @@ Object.defineProperty(exports, "forgetPromptCardMemory", { enumerable: true, get
 Object.defineProperty(exports, "promptCardCount", { enumerable: true, get: function () { return prompt_card_state_1.promptCardCount; } });
 Object.defineProperty(exports, "PROMPT_CARD_KEY_PREFIX", { enumerable: true, get: function () { return prompt_card_state_1.PROMPT_CARD_KEY_PREFIX; } });
 Object.defineProperty(exports, "PROMPT_CARD_MAX_AGE_MS", { enumerable: true, get: function () { return prompt_card_state_1.PROMPT_CARD_MAX_AGE_MS; } });
+// The model edge's push (Issue #2357).
+// NOTE: `realtime/model-change-broadcast` imports these from
+// './model-change-push-notifier' directly, for the reason every block above
+// gives — a suite that stubs the whole '@/lib/push' barrel would otherwise
+// leave the notifier undefined on the path it guards.
+var model_change_push_notifier_1 = require("./model-change-push-notifier");
+Object.defineProperty(exports, "notifyModelChangePush", { enumerable: true, get: function () { return model_change_push_notifier_1.notifyModelChangePush; } });
+Object.defineProperty(exports, "buildModelChangedSentence", { enumerable: true, get: function () { return model_change_push_notifier_1.buildModelChangedSentence; } });
+Object.defineProperty(exports, "buildModelChangedBodies", { enumerable: true, get: function () { return model_change_push_notifier_1.buildModelChangedBodies; } });
+Object.defineProperty(exports, "resolveReadersLocale", { enumerable: true, get: function () { return model_change_push_notifier_1.resolveReadersLocale; } });
+var push_sender_2 = require("./push-sender");
+Object.defineProperty(exports, "MODEL_CHANGE_TAG_SUFFIX", { enumerable: true, get: function () { return push_sender_2.MODEL_CHANGE_TAG_SUFFIX; } });