commandmate 0.29.1 → 0.30.0

package/dist/server/src/lib/session/claude-session.js

@@ -19,6 +19,9 @@ exports.stopClaudeSession = stopClaudeSession;
 exports.restartClaudeSession = restartClaudeSession;
 const tmux_1 = require("../../lib/tmux/tmux");
 const cli_patterns_1 = require("../../lib/detection/cli-patterns");
+const tool_liveness_1 = require("../../lib/detection/tool-liveness");
+const liveness_spec_1 = require("../../lib/cli-tools/liveness-spec");
+const session_liveness_1 = require("../../lib/cli-tools/session-liveness");
 const session_key_sender_1 = require("../../lib/session-key-sender");
 const child_process_1 = require("child_process");
 const util_1 = require("util");
@@ -45,22 +48,20 @@ function getErrorMessage(error) {
 }
 // ----- Shell Prompt Detection Constants -----
 /**
- * Shell prompt ending characters for detecting shell-only tmux sessions
- * Extensible array to support multiple shell types (MF-002: OCP)
- * Placed in claude-session.ts as private constant (SF-S2-002: ISP - used only by isSessionHealthy())
- * - '$': bash/sh default prompt
- * - '%': zsh default prompt
- * - '#': root prompt (bash/zsh)
- *
- * C-S2-002: False positive risk assessment:
- * These characters are checked only at the END of trimmed output. This limits false
- * positives to cases where Claude CLI output ends with one of these characters
- * (e.g., output containing "$" at end of a code block). The risk is acceptable because:
- * (1) Claude CLI output typically ends with a prompt (❯) or thinking indicator, not shell chars
- * (2) A false positive triggers session recreation, which is a safe recovery action
- * (3) The check is combined with error pattern detection for multiple signals
+ * Issue #2070: the shell-prompt endings, the 40-character gate and the
+ * error-pattern tail this module used to declare privately are now
+ * `SHELL_PROMPT_ENDINGS` / `MAX_SHELL_PROMPT_LENGTH` / `FATAL_PATTERN_TAIL_LINES`
+ * in `lib/detection/tool-liveness`, and claude's use of them is
+ * `resolveLivenessSpec('claude')`.
+ *
+ * They moved because the rule they describe was never claude-specific — only
+ * these values were. A tmux session that outlives its agent looks the same for
+ * codex, copilot, opencode and gemini, and every one of them reported `running`
+ * for a pane that had fallen back to the shell, because the only check for it
+ * sat behind `cliToolId === 'claude'`. The values themselves are unchanged, and
+ * `tests/unit/lib/claude-session.test.ts` still pins every verdict this
+ * function reaches.
  */
-const SHELL_PROMPT_ENDINGS = ['$', '%', '#'];
 // ----- Timeout and Polling Constants (OCP-001) -----
 // These constants are exported to allow configuration and testing.
 // Changing these values affects Claude CLI session startup behavior.
@@ -160,27 +161,12 @@ exports.CLAUDE_SEND_PROMPT_WAIT_TIMEOUT = 10000;
  */
 exports.CLAUDE_PROMPT_POLL_INTERVAL = 200;
 /**
- * Maximum expected length of a shell prompt line (characters)
- *
- * Shell prompts are typically under 40 characters (e.g., "user@host:~/project$" ~30 chars).
- * Lines at or above this threshold are not considered shell prompts, preventing
- * false positives from Claude CLI output that happens to end with $, %, or #.
- *
- * Used by isSessionHealthy() to distinguish shell prompts from CLI output.
- * 40 is an empirical threshold with safety margin.
- */
-const MAX_SHELL_PROMPT_LENGTH = 40;
-/**
- * Number of tail lines used for error pattern detection in isSessionHealthy()
- *
- * Error patterns are only searched within the last N lines of pane output,
- * not the entire buffer. This prevents false negatives where historical
- * (already recovered) errors in the scrollback trigger unhealthy detection.
- *
- * 10 lines provides sufficient window to catch recent errors while ignoring
- * historical ones that have scrolled up.
+ * Issue #2070: `MAX_SHELL_PROMPT_LENGTH` and `HEALTH_CHECK_ERROR_TAIL_LINES`
+ * moved to `lib/detection/tool-liveness` with the rule that reads them. Their
+ * values are unchanged and claude reaches them through
+ * `resolveLivenessSpec('claude')`.
  */
-const HEALTH_CHECK_ERROR_TAIL_LINES = 10;
+const CLAUDE_LIVENESS_SPEC = (0, liveness_spec_1.resolveLivenessSpec)('claude');
 /**
  * Cached Claude CLI path
  */
@@ -294,30 +280,17 @@ async function getCleanPaneOutput(sessionName, lines = 50) {
  * already printed "Claude Code cannot be launched inside another Claude Code
  * session" must not sit there burning the whole budget before saying so.
  *
- * Only the last {@link HEALTH_CHECK_ERROR_TAIL_LINES} lines are searched, so a
- * historical error that has scrolled up cannot condemn a session that recovered.
+ * Only the last `FATAL_PATTERN_TAIL_LINES` lines are searched, so a historical
+ * error that has scrolled up cannot condemn a session that recovered.
+ *
+ * Issue #2070: the search itself is `findFatalPattern`, shared with every other
+ * tool's liveness probe; claude's patterns ride in its `ToolLivenessSpec`.
  *
  * @param cleanOutput - ANSI-stripped pane output
  * @returns The matched pattern (or regex source) for the log, or null
  */
 function findSessionErrorPattern(cleanOutput) {
-    const allLines = cleanOutput
-        .trim()
-        .split('\n')
-        .filter((line) => line.trim() !== '');
-    const tailText = allLines.slice(-HEALTH_CHECK_ERROR_TAIL_LINES).join('\n');
-    // MF-001: Check error patterns from cli-patterns.ts (SRP - pattern management centralized)
-    for (const pattern of cli_patterns_1.CLAUDE_SESSION_ERROR_PATTERNS) {
-        if (tailText.includes(pattern)) {
-            return pattern;
-        }
-    }
-    for (const regex of cli_patterns_1.CLAUDE_SESSION_ERROR_REGEX_PATTERNS) {
-        if (regex.test(tailText)) {
-            return regex.source;
-        }
-    }
-    return null;
+    return (0, tool_liveness_1.findFatalPattern)(cleanOutput, CLAUDE_LIVENESS_SPEC);
 }
 /**
  * Verify that Claude CLI is actually running inside a tmux session
@@ -327,64 +300,22 @@ function findSessionErrorPattern(cleanOutput) {
  * Used by worktrees/route.ts and worktrees/[id]/route.ts for
  * health-aware session status with listSessions() batch optimization.
  *
+ * Issue #2070: the algorithm moved to `judgeToolLiveness`, which is the same
+ * rule read through claude's `ToolLivenessSpec`. Every branch, every reason
+ * string and every ordering decision this function used to spell inline is
+ * preserved there — the empty-output verdict, the whole-frame
+ * `CLAUDE_PROMPT_PATTERN` check BEFORE the error patterns (so a recovered
+ * session is not condemned by scrollback), the 40-character gate, and the
+ * `\d+%$` carve-out that keeps `Context left until auto-compact: 7%` from
+ * reading as a zsh prompt. What changed is that six other tools can now be
+ * asked the same question; see `lib/cli-tools/liveness-spec`.
+ *
  * @param sessionName - tmux session name
  * @returns HealthCheckResult with healthy status and optional reason
  */
 async function isSessionHealthy(sessionName) {
-    try {
-        // SF-001: Use shared helper instead of inline capturePane + stripAnsi
-        const cleanOutput = await getCleanPaneOutput(sessionName);
-        // MF-002: Check shell prompt endings from extensible array (OCP)
-        const trimmed = cleanOutput.trim();
-        // S2-F010: Empty output judgment (HealthCheckResult format)
-        // C-S2-001: Empty output means tmux session exists but Claude CLI has no output.
-        // This is treated as unhealthy because a properly running Claude CLI always
-        // produces output (prompt, spinner, or response). An empty pane indicates
-        // the CLI process has exited or failed to start.
-        if (trimmed === '') {
-            return { healthy: false, reason: 'empty output' };
-        }
-        // Active state detection: check for Claude prompt BEFORE error patterns.
-        // This prevents false negatives where historical (recovered) errors in
-        // the pane scrollback cause a currently-active session to be marked unhealthy.
-        if (cli_patterns_1.CLAUDE_PROMPT_PATTERN.test(trimmed)) {
-            return { healthy: true };
-        }
-        // S2-F010: Error pattern detection - limited to tail lines only.
-        // Only the last HEALTH_CHECK_ERROR_TAIL_LINES lines are searched, so
-        // historical errors that have scrolled up do not trigger false negatives.
-        const allLines = trimmed.split('\n').filter(line => line.trim() !== '');
-        const errorPattern = findSessionErrorPattern(trimmed);
-        if (errorPattern !== null) {
-            return { healthy: false, reason: `error pattern: ${errorPattern}` };
-        }
-        // S2-F002: Extract last line after empty line filtering
-        const lastLine = allLines[allLines.length - 1]?.trim() ?? '';
-        // F006: Line length check BEFORE SHELL_PROMPT_ENDINGS check (early return)
-        if (lastLine.length >= MAX_SHELL_PROMPT_LENGTH) {
-            // Long lines are not shell prompts -> treat as healthy (early return)
-            return { healthy: true };
-        }
-        // F003: Individual pattern exclusions for SHELL_PROMPT_ENDINGS
-        // NOTE(F003): If new false positive patterns are found in the future,
-        // consider refactoring to a structure that associates exclusionPattern
-        // with each SHELL_PROMPT_ENDINGS entry. Currently only % needs exclusion (YAGNI).
-        if (SHELL_PROMPT_ENDINGS.some(ending => {
-            if (!lastLine.endsWith(ending))
-                return false;
-            // Exclude N% pattern (e.g., "Context left until auto-compact: 7%")
-            if (ending === '%' && /\d+%$/.test(lastLine))
-                return false;
-            return true;
-        })) {
-            return { healthy: false, reason: `shell prompt ending detected: ${lastLine}` };
-        }
-        return { healthy: true };
-    }
-    catch {
-        // S3-F001: Catch block also returns HealthCheckResult format
-        return { healthy: false, reason: 'capture error' };
-    }
+    const verdict = await (0, session_liveness_1.probeSessionLiveness)(sessionName, CLAUDE_LIVENESS_SPEC);
+    return verdict.alive ? { healthy: true } : { healthy: false, reason: verdict.reason };
 }
 /**
  * Ensure the existing tmux session has a healthy Claude CLI process

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

@@ -7,18 +7,55 @@
  * over WebSocket (terminal streaming), keeping the pull (HTTP) and push (WS)
  * paths byte-for-byte consistent (DRY).
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeStructuredStatus = mergeStructuredStatus;
 exports.buildCurrentOutput = buildCurrentOutput;
+exports.resetChatTurnProgressState = resetChatTurnProgressState;
+exports.buildChatTurnProgress = buildChatTurnProgress;
+exports.emitChatTurnProgress = emitChatTurnProgress;
 const db_1 = require("../../lib/db");
 const unclassified_frame_tracker_1 = require("../../lib/detection/unclassified-frame-tracker");
 const composer_text_1 = require("../../lib/detection/composer-text");
 const upstream_faults_1 = require("../../lib/detection/upstream-faults");
 const opencode_pane_obstruction_1 = require("../../lib/detection/opencode-pane-obstruction");
+const types_1 = require("../../lib/realtime/types");
 const models_1 = require("../../types/models");
 const logger_1 = require("../../lib/logger");
 const manager_1 = require("../../lib/cli-tools/manager");
-const types_1 = require("../../lib/cli-tools/types");
+const types_2 = require("../../lib/cli-tools/types");
 const registry_1 = require("../../lib/hooks/sources/registry");
 const define_source_1 = require("../../lib/hooks/sources/define-source");
 const subscription_1 = require("../../lib/hooks/sources/opencode/subscription");
@@ -93,6 +130,44 @@ function describePaneObstruction(obstruction) {
         `${JSON.stringify(obstruction.matchedText)}), which covers the marker that ends a ` +
         `turn. Press \`${opencode_pane_obstruction_1.OPENCODE_SIDEBAR_RECOVERY_CHORD}\` in the pane to close it.`);
 }
+/**
+ * Push a history row this module just wrote to the worktree room (Issue #2214).
+ *
+ * Always `'message'`: both callers INSERT a brand-new row, so nothing has been
+ * delivered for it before and the client appends rather than replaces.
+ *
+ * Detached on purpose, and for two reasons that both matter here:
+ *
+ *  - the `ws-server` import stays dynamic, which is the same bargain
+ *    {@link emitChatTurnProgress} strikes — this module's *other* callers (the
+ *    `/current-output` route and the terminal push) must not pull the WebSocket
+ *    server into their graph just by building a payload;
+ *  - the row is already committed when this runs, so a socket write can never
+ *    turn a written row into a failed one. The two record functions below are
+ *    best-effort by contract and their callers are waiting on a payload.
+ *
+ * #2214 recorded a limitation here — a route bundle holding its own empty copy
+ * of `ws-server`'s `rooms` under `next dev` — and added that "production runs
+ * one custom-server bundle and is unaffected". **That last clause was wrong.**
+ * `npm run dev` and `npm start` run the *same* custom server (`tsx server.ts`
+ * vs `node dist/server/server.js`); what differs is only whether Next evaluates
+ * a route handler from a dev compilation or from `.next/server`. Either way the
+ * route handler's copy of this module and of `ws-server` is not the custom
+ * server's, so this push was silent in production too. #2220 bridged it: the
+ * `broadcastMessage` below now reaches the socket owner through
+ * `lib/realtime/publisher-registry` regardless of which graph called it.
+ */
+function broadcastRecordedRow(worktreeId, message) {
+    void Promise.resolve().then(() => __importStar(require('../../lib/ws-server'))).then(({ broadcastMessage }) => {
+        broadcastMessage('message', { worktreeId, message });
+    })
+        .catch((error) => {
+        logger.warn('history-row-broadcast-failed', {
+            worktreeId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    });
+}
 function recordUnclassifiedFrame(db, params) {
     const dwellSeconds = Math.round(params.dwellMs / 1000);
     const statusReason = `${params.sessionStatus}/${params.sessionStatusReason}`;
@@ -114,7 +189,7 @@ function recordUnclassifiedFrame(db, params) {
         sessionStatusReason: statusReason,
     };
     try {
-        (0, db_1.createMessage)(db, {
+        const message = (0, db_1.createMessage)(db, {
             worktreeId: params.worktreeId,
             role: 'assistant',
             content: question,
@@ -133,6 +208,10 @@ function recordUnclassifiedFrame(db, params) {
             dwellSeconds,
             statusReason,
         });
+        // `cliToolId` / `instanceId` are already the explicit values passed above —
+        // `createMessage` hands back the caller's own object — so the published row
+        // addresses the same instance the column does.
+        broadcastRecordedRow(params.worktreeId, message);
     }
     catch (error) {
         logger.warn('unclassified-frame-record-failed', {
@@ -166,7 +245,7 @@ function recordUnclassifiedFrame(db, params) {
 function recordStructuredPrompt(db, params) {
     const record = (0, structured_prompt_1.buildStructuredPromptHistoryRecord)(params.worktreeId, params.facts);
     try {
-        (0, db_1.createMessage)(db, {
+        const message = (0, db_1.createMessage)(db, {
             worktreeId: params.worktreeId,
             role: 'assistant',
             content: record.question,
@@ -187,6 +266,7 @@ function recordStructuredPrompt(db, params) {
             source: params.state.source,
             toolName: params.state.toolName,
         });
+        broadcastRecordedRow(params.worktreeId, message);
     }
     catch (error) {
         logger.warn('structured-prompt-record-failed', {
@@ -371,6 +451,17 @@ function hookClosedTurn(turn) {
  */
 async function buildCurrentOutput(db, worktreeId, cliToolId, instanceId, resolution) {
     const payload = await buildPayload(db, worktreeId, cliToolId, instanceId);
+    // Issue #2199. Fire-and-forget, and placed HERE rather than in the poller for
+    // one reason: this is the function both live paths run through. The WebSocket
+    // push calls it from `broadcastTerminalSnapshot` on every generating poller
+    // tick, and the HTTP `/current-output` poll calls it at the same cadence when
+    // the push is down — so the progress frames appear at whatever rate the
+    // surface is actually being watched at, which is exactly the property the
+    // terminal snapshot already has. Gated on the merged verdict (`'running'`, not
+    // the tmux-session-exists `isRunning`) so an idle pane reads no transcript.
+    if (payload.isRunning && payload.sessionStatus === 'running') {
+        void publishChatTurnProgress(db, worktreeId, cliToolId, instanceId);
+    }
     if (!resolution)
         return payload;
     return {
@@ -573,7 +664,7 @@ async function buildPayload(db, worktreeId, cliToolId, instanceId) {
     // value is the pane height, `slice()` starts past the last row, and `content`
     // — the field `commandmate capture <id>` prints — was an empty string.
     // `capturedLineCountIsCursor` states both conditions in one place.
-    const lineCountIsCursor = (0, types_1.capturedLineCountIsCursor)(cliToolId, captureWindowSaturated);
+    const lineCountIsCursor = (0, types_2.capturedLineCountIsCursor)(cliToolId, captureWindowSaturated);
     const newLines = lineCountIsCursor ? lines.slice(Math.max(0, lastCapturedLine)) : lines;
     const newContent = newLines.join('\n');
     const compositeKey = (0, auto_yes_manager_1.buildCompositeKey)(worktreeId, cliToolId, instanceId);
@@ -946,3 +1037,171 @@ async function buildPayload(db, worktreeId, cliToolId, instanceId) {
         composerState: composer.state,
     };
 }
+/**
+ * On `globalThis` for the reason every shared map in this subsystem is (#1736):
+ * under `next dev` the poller's bundle and the opencode subscription's bundle
+ * would each get a private copy, and two producers throttling against two
+ * different maps is no throttle at all.
+ */
+const chatTurnProgressState = (globalThis.__chatTurnProgressState ??= new Map());
+function chatTurnProgressKey(target) {
+    return `${target.worktreeId}:${target.cliToolId}:${target.instanceId ?? target.cliToolId}`;
+}
+/** Forget every instance's progress bookkeeping. Test seam. */
+function resetChatTurnProgressState() {
+    chatTurnProgressState.clear();
+}
+/**
+ * Decide whether this instance has a new progress frame, and build it.
+ *
+ * The single generator both tools go through, on the same argument
+ * {@link buildCurrentOutput} makes for the terminal payload: two producers of one
+ * wire shape drift, and the drift is invisible because each of them is
+ * individually correct. Three rules, in this order, and each of them is a way
+ * this feature goes wrong if it is missing:
+ *
+ *  1. **Throttle.** At most one *ask* per {@link CHAT_TURN_PROGRESS_MIN_INTERVAL_MS}
+ *     per instance. It gates the ask rather than the send because the source is
+ *     the expensive half (see {@link ChatTurnProgressSource}); a gate on the send
+ *     alone would re-read a 4 MiB transcript to discover it had not changed.
+ *  2. **No-change suppression.** Same turn, same body → no frame. A reply that
+ *     has stopped growing must not keep waking every subscribed browser.
+ *  3. **Monotonic version**, per instance and NOT per turn. A client drops
+ *     anything at or below what it has already rendered, and restarting the
+ *     counter on a new turn would make the first frame of turn N+1 look stale
+ *     against the last frame of turn N.
+ *
+ * The body is bounded by {@link truncateChatTurnProgressBody}, whose cut is
+ * folded into `partial` together with the reader's own — see
+ * {@link ChatTurnProgressEvent.partial} for why one flag answers both.
+ *
+ * Never throws: a source that throws is a turn with nothing to show, not a
+ * broken poll tick.
+ *
+ * @param target - The instance
+ * @param source - Asked only when the throttle allows it
+ * @param now - Epoch ms; injected by the tests
+ * @returns The frame to broadcast, or null when there is nothing new to say
+ */
+async function buildChatTurnProgress(target, source, now = Date.now()) {
+    const key = chatTurnProgressKey(target);
+    const state = chatTurnProgressState.get(key) ?? {
+        version: 0,
+        askedAt: Number.NEGATIVE_INFINITY,
+        turnKey: null,
+        body: null,
+    };
+    if (now - state.askedAt < types_1.CHAT_TURN_PROGRESS_MIN_INTERVAL_MS)
+        return null;
+    state.askedAt = now;
+    chatTurnProgressState.set(key, state);
+    let draft;
+    try {
+        draft = await source();
+    }
+    catch {
+        // The readers already promise never to throw; this is the belt for the
+        // dynamic import that reaches them.
+        return null;
+    }
+    if (!draft || draft.body.length === 0)
+        return null;
+    const bounded = (0, types_1.truncateChatTurnProgressBody)(draft.body);
+    if (draft.turnKey === state.turnKey && bounded.body === state.body)
+        return null;
+    state.turnKey = draft.turnKey;
+    state.body = bounded.body;
+    state.version += 1;
+    return {
+        type: types_1.CHAT_TURN_PROGRESS_EVENT_TYPE,
+        worktreeId: target.worktreeId,
+        cliToolId: target.cliToolId,
+        instanceId: target.instanceId ?? target.cliToolId,
+        turnKey: draft.turnKey,
+        body: bounded.body,
+        partial: bounded.truncated || draft.partial === true,
+        version: state.version,
+        done: false,
+    };
+}
+/**
+ * Build a progress frame and push it to the worktree room.
+ *
+ * Subscribers are checked FIRST, before the throttle state is touched and long
+ * before the source is asked, so a session nobody is watching costs one map
+ * lookup per tick — the same bargain `broadcastTerminalSnapshot` strikes, and
+ * the reason a 4 MiB transcript read does not happen for every claude session on
+ * the machine.
+ *
+ * The `ws-server` import is dynamic so this module's *other* callers — the
+ * `/current-output` route and `commandmate capture` — do not pull the WebSocket
+ * server into their graph just by building a payload.
+ *
+ * Never throws; a failed push is a moment of staleness on a surface that has the
+ * settled row coming anyway.
+ *
+ * @returns Whether a frame was broadcast
+ */
+async function emitChatTurnProgress(target, source, now = Date.now()) {
+    try {
+        const { broadcast, hasRoomSubscribers } = await Promise.resolve().then(() => __importStar(require('../../lib/ws-server')));
+        if (!hasRoomSubscribers(target.worktreeId))
+            return false;
+        const event = await buildChatTurnProgress(target, source, now);
+        if (!event)
+            return false;
+        broadcast(target.worktreeId, event);
+        return true;
+    }
+    catch (error) {
+        logger.debug('chat-turn-progress-failed', {
+            worktreeId: target.worktreeId,
+            cliToolId: target.cliToolId,
+            instanceId: target.instanceId ?? target.cliToolId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return false;
+    }
+}
+/**
+ * Ask the tool that has a transcript for the body of its open turn (Issue #2199).
+ *
+ * claude only, and that is a statement about which tools have a *pull* reader
+ * rather than a list to extend by hand. opencode's body arrives on its own SSE
+ * stream and is published from `sources/opencode/history` at the moment a part
+ * lands — polling for it here would be a second producer of the same frames.
+ * codex and antigravity have neither, and stay on the indicator (#2197 / #2198).
+ *
+ * The reader is imported dynamically so `sources/claude/history` — and through
+ * it `fs/promises`, the session-pointer latch and `user-turn-recorder` — stays
+ * out of the module graph of the `/current-output` route and of `commandmate
+ * capture`, both of which reach this file for a payload and nothing else.
+ *
+ * Never throws: `emitChatTurnProgress` swallows, and so does this.
+ */
+async function publishChatTurnProgress(db, worktreeId, cliToolId, instanceId) {
+    if (cliToolId !== 'claude')
+        return;
+    try {
+        // The slug the transcript directory is named after is a function of the
+        // worktree's path, so the row is what makes the file findable at all. Read
+        // before the throttle only because it is a single indexed lookup against a
+        // connection this function was handed; everything expensive is behind the
+        // gate.
+        const { getWorktreeById } = await Promise.resolve().then(() => __importStar(require('../../lib/db/worktree-db')));
+        const worktreePath = getWorktreeById(db, worktreeId)?.path;
+        if (!worktreePath)
+            return;
+        await emitChatTurnProgress({ worktreeId, cliToolId, instanceId }, async () => {
+            const { readClaudeTurnProgress } = await Promise.resolve().then(() => __importStar(require('../../lib/hooks/sources/claude/history')));
+            return readClaudeTurnProgress({ worktreeId, cliToolId, instanceId: instanceId ?? cliToolId }, { worktreePath });
+        });
+    }
+    catch (error) {
+        logger.debug('chat-turn-progress-claude-failed', {
+            worktreeId,
+            instanceId: instanceId ?? cliToolId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}

package/dist/server/src/lib/session/send-user-message.js

@@ -14,7 +14,13 @@
  *   3. copilot /model command        — Issue #576 (copilot only)
  *   4. send to CLI tool              — image branch / ICLITool.sendMessage
  *   5. createMessage (role: 'user')  — INSERT INTO chat_messages (History source)
+ *   5b. broadcastMessage('message')  — Issue #2195, push the user row to every
+ *                                      open pane (the send that produced it is
+ *                                      not necessarily on this device)
  *   6. orphan deletion               — remove prior duplicate after persist
+ *   6b. broadcastMessage(              — Issue #2219, tell every open pane for
+ *         'messages_invalidated')        this instance to re-read its history:
+ *                                        a delete has no row to publish
  *   7. updateLastUserMessage
  *   8. clearInProgressMessageId
  *   9. startPolling                  — record the assistant response afterwards
@@ -30,6 +36,8 @@ const manager_1 = require("../../lib/cli-tools/manager");
 const types_1 = require("../../lib/cli-tools/types");
 const response_poller_1 = require("../../lib/polling/response-poller");
 const assistant_response_saver_1 = require("../../lib/assistant-response-saver");
+const ws_server_1 = require("../../lib/ws-server");
+const types_2 = require("../../lib/realtime/types");
 const logger_1 = require("../../lib/logger");
 const prompt_waiting_guard_1 = require("../../lib/session/prompt-waiting-guard");
 const opencode_1 = require("../../lib/cli-tools/opencode");
@@ -47,6 +55,14 @@ function getErrorMessage(error) {
 async function sendUserMessage(db, params) {
     const { worktreeId, content, cliToolId, instanceId, absoluteImagePath, copilotModel } = params;
     const messageType = params.messageType ?? 'normal';
+    /**
+     * The instance this send belongs to, resolved the way `createMessage` and
+     * `mapChatMessage` resolve it (Issue #868: the primary instance's id *is* the
+     * tool's id). Callers omit `instanceId` for the primary instance — the UI and
+     * the send API both do — so every scope decision below has to resolve it
+     * first or it is not scoped at all.
+     */
+    const resolvedInstanceId = instanceId ?? cliToolId;
     const cliTool = manager_1.CLIToolManager.getInstance().getTool(cliToolId);
     // Issue #1708: refuse before the first side effect. A prompt dialog does not
     // forward keystrokes to the agent — they accumulate in its own input line — so
@@ -94,12 +110,31 @@ async function sendUserMessage(db, params) {
         logger.error('failed-to-save-pending-assistant-response:', { error: getErrorMessage(error) });
     }
     // 2. Clean up orphaned user messages (Issue #379: duplicate message prevention).
-    // If the most recent message for this cliToolId is a user message with the same
+    // If the most recent message for THIS INSTANCE is a user message with the same
     // content, the assistant never responded and the user is retrying. Remove it
     // (only after the retry message is persisted) to prevent duplicates.
+    //
+    // Issue #2219: the scope is `resolvedInstanceId`, not the caller's raw
+    // `instanceId`. `getMessages` filters on the instance *or* the tool, never
+    // both, so passing an omitted `instanceId` through fell back to the tool
+    // filter and made this search read the newest row of **every instance of that
+    // tool**. A primary-instance re-send whose text matched `claude-2`'s last user
+    // row therefore deleted a row belonging to another session — data loss, not a
+    // display delay, and invisible because the delete is best-effort and silent.
+    //
+    // `matchResolvedInstance` is what makes the fix safe rather than merely
+    // narrow: a bare `instance_id = ?` would hide every pre-#868 row (they carry
+    // NULL and read back as the primary instance), so the orphan they are would
+    // survive as a visible duplicate. Same expression as #2196's
+    // `findUnkeyedUserMessages`.
     let orphanedMessageIdToDelete = null;
     try {
-        const recentMessages = (0, db_1.getMessages)(db, worktreeId, { limit: 1, cliToolId, instanceId });
+        const recentMessages = (0, db_1.getMessages)(db, worktreeId, {
+            limit: 1,
+            cliToolId,
+            instanceId: resolvedInstanceId,
+            matchResolvedInstance: true,
+        });
         if (recentMessages.length > 0 &&
             recentMessages[0].role === 'user' &&
             recentMessages[0].content === content) {
@@ -169,6 +204,31 @@ async function sendUserMessage(db, params) {
         cliToolId,
         instanceId,
     });
+    // 5b. Broadcast the user row (Issue #2195).
+    //
+    // Every other history writer already does this; this one did not, so a second
+    // device (or a second pane on the same device) saw a message it did not send
+    // only on its next poll — and #2195 stretches that poll to 15s while a socket
+    // is up, which would have made the omission three times as visible.
+    //
+    // `createMessage` hands back the caller's own object rather than re-reading
+    // the row, so `instanceId` here would be `undefined` whenever the caller
+    // omitted it. It is resolved to the primary instance (=== cliToolId) exactly
+    // as `createMessage` resolves it for the column, so the client's
+    // (worktreeId, cliToolId, instanceId) match cannot miss.
+    //
+    // Wrapped because the message is already sent and already persisted by this
+    // point: a socket write that throws must not turn a successful send into a
+    // failure the caller reports to the user.
+    try {
+        (0, ws_server_1.broadcastMessage)('message', {
+            worktreeId,
+            message: { ...message, cliToolId, instanceId: resolvedInstanceId },
+        });
+    }
+    catch (error) {
+        logger.warn('user-message-broadcast-failed', { error: getErrorMessage(error) });
+    }
     // 6. Remove the prior orphan only after the retry message is persisted.
     // This avoids data loss if send/create fails partway through.
     if (orphanedMessageIdToDelete) {
@@ -176,6 +236,34 @@ async function sendUserMessage(db, params) {
             const deleted = (0, db_1.deleteMessageById)(db, orphanedMessageIdToDelete);
             if (deleted) {
                 logger.info('cleaned-up-orphaned-user');
+                // 6b. Issue #2219: publish the delete.
+                //
+                // The `message` frame above told every pane about the row that was
+                // added; nothing told them about the row that went away, because the
+                // event contract has no shape for a deletion — `message_updated` can
+                // only say what a row now looks like. A second device therefore kept
+                // showing the old copy next to the new one until its own poll, which
+                // #2195 demoted to a 15s fallback while a socket is up.
+                //
+                // A scope rather than an id: the receiver re-reads its history, so it
+                // lands on the settled DB state and a `message` frame that was dropped
+                // on the way is repaired by the same round trip. See
+                // MESSAGES_INVALIDATED_EVENT_TYPE.
+                //
+                // Wrapped separately from the delete: the row is already gone by now,
+                // and #379's cleanup has always been best-effort — a socket write that
+                // throws must not turn a completed send into a reported failure.
+                try {
+                    (0, ws_server_1.broadcastMessage)(types_2.MESSAGES_INVALIDATED_EVENT_TYPE, {
+                        worktreeId,
+                        cliToolId,
+                        instanceId: resolvedInstanceId,
+                        reason: 'orphan_cleanup',
+                    });
+                }
+                catch (error) {
+                    logger.warn('orphan-cleanup-broadcast-failed', { error: getErrorMessage(error) });
+                }
             }
         }
         catch (error) {