commandmate 0.44.3 → 0.45.0

package/dist/server/src/lib/detection/model-info-extractor.js

@@ -42,6 +42,7 @@
  * | copilot     | footer:  `← open sidebar · … · tab next tab      GPT-5 mini · Medium` |
  * | copilot     | notice:  `● Model changed from gpt-5.6-terra (xhigh) to gpt-5-mini (medium) for this session.` |
  * | opencode    | step:    `▣  Build · GPT-5.6 Luna · 3.1s`                          |
+ * | opencode2   | step:    `Build · Mistral Large 4 · 253ms` (no `▣`, 2.0.18, #3443)  |
  *
  * The copilot and opencode rows were added by Issue #1912 and read off the live
  * fixtures #1885 / #1895 / #1893 / #1896 recorded, not off a fresh capture.
@@ -62,7 +63,7 @@
  * @see Issue #1784, Phase 2 of the model/effort visibility series
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ANTIGRAVITY_MODEL_ID_EFFORT_PATTERN = exports.COMMAND_CODE_BANNER_MODELS_PATTERN = exports.OPENCODE_STEP_MODEL_PATTERN = exports.COPILOT_MODEL_CHANGE_PATTERN = exports.ANTIGRAVITY_BANNER_MODEL_PATTERN = exports.ANTIGRAVITY_STATUS_BAR_HINT_PATTERN = exports.CLAUDE_MODEL_SWITCH_PATTERN = exports.CLAUDE_EFFORT_ROW_PATTERN = exports.CLAUDE_STARTUP_BANNER_V2_1_28X_PATTERN = exports.CLAUDE_STARTUP_BANNER_PATTERN = exports.CODEX_STATUS_BAR_WITH_TRAILER_PATTERN = exports.CODEX_FOOTER_EFFORT_SLOT_PATTERN = exports.CODEX_FOOTER_MODEL_PATTERN = exports.REASONING_EFFORT_LEVELS = void 0;
+exports.ANTIGRAVITY_MODEL_ID_EFFORT_PATTERN = exports.COMMAND_CODE_BANNER_MODELS_PATTERN = exports.OPENCODE_V2_STEP_MODEL_PATTERN = exports.OPENCODE_STEP_MODEL_PATTERN = exports.COPILOT_MODEL_CHANGE_PATTERN = exports.ANTIGRAVITY_BANNER_MODEL_PATTERN = exports.ANTIGRAVITY_STATUS_BAR_HINT_PATTERN = exports.CLAUDE_MODEL_SWITCH_PATTERN = exports.CLAUDE_EFFORT_ROW_PATTERN = exports.CLAUDE_STARTUP_BANNER_V2_1_28X_PATTERN = exports.CLAUDE_STARTUP_BANNER_PATTERN = exports.CODEX_STATUS_BAR_WITH_TRAILER_PATTERN = exports.CODEX_FOOTER_EFFORT_SLOT_PATTERN = exports.CODEX_FOOTER_MODEL_PATTERN = exports.REASONING_EFFORT_LEVELS = void 0;
 exports.resolveEffortToken = resolveEffortToken;
 exports.extractModelInfo = extractModelInfo;
 exports.deriveEffortFromModelId = deriveEffortFromModelId;
@@ -684,6 +685,58 @@ function readOpencodeStepMarker(line) {
     const model = match[1].trim();
     return isPlausibleModelLabel(model) ? { model, effort: null } : null;
 }
+/**
+ * opencode2's step row (Issue #3443): v1's marker without the `▣`.
+ *
+ * Measured on opencode2 2.0.18 (`tests/fixtures/opencode-agent-health-3420/`):
+ *
+ *   `     Error: Unauthorized`
+ *   `     Build · Mistral Large 4 · 721ms`
+ *   `  ┃`                                   (the next user turn, or the composer)
+ *
+ * Without the `▣` the shape `<word> · <text> · <duration>` is ordinary prose, so
+ * it is only read under three guards, each of which a v1 step row also meets:
+ *
+ * - the duration is required (a row with two `·` and nothing timed is not one);
+ * - the row is transcript text, not inside a `┃` block — the user's own input
+ *   and shell output are drawn inside one, the composer bar too;
+ * - the next non-blank row opens a `┃` block (the next user turn or the
+ *   composer): the step row closes a reply, so a reply line that merely has the
+ *   shape is followed by more reply, or by the step row itself.
+ *
+ * No /g. No nested quantifiers: `[^·]+?` is bounded by literal `·`.
+ */
+exports.OPENCODE_V2_STEP_MODEL_PATTERN = /^\s*[A-Za-z][A-Za-z0-9-]*\s+·\s+([^·]+?)\s+·\s+[\d.]+\s?m?s\s*$/;
+/** A row that opens or continues opencode's `┃` block (a user turn or the composer). */
+const OPENCODE_BLOCK_ROW_PATTERN = /^\s*[┃╹]/;
+function readOpencodeV2StepRow(lines, index) {
+    const match = exports.OPENCODE_V2_STEP_MODEL_PATTERN.exec(lines[index]);
+    if (!match)
+        return null;
+    const model = match[1].trim();
+    if (!isPlausibleModelLabel(model))
+        return null;
+    for (let next = index + 1; next < lines.length; next++) {
+        if (lines[next].trim() === '')
+            continue;
+        return OPENCODE_BLOCK_ROW_PATTERN.test(lines[next]) ? { model, effort: null } : null;
+    }
+    return null;
+}
+/**
+ * The lowest opencode step row, `▣` (v1) or not (opencode2, #3443). Both tool
+ * ids read both shapes: `opencode` may be running a 2.x binary, and a v1 frame
+ * never draws a `▣`-less row that passes {@link readOpencodeV2StepRow}'s guards.
+ */
+function readOpencodeStepRow(captureText) {
+    const lines = captureText.split('\n').map((line) => (0, ansi_1.stripAnsi)(line));
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const result = readOpencodeStepMarker(lines[i]) ?? readOpencodeV2StepRow(lines, i);
+        if (result)
+            return result;
+    }
+    return null;
+}
 // =============================================================================
 // Command Code (Issue #2358)
 // =============================================================================
@@ -792,7 +845,7 @@ function scanFromEnd(captureText, read) {
  * Pure and side-effect free. Never throws, and answers `{ model: null, effort:
  * null }` for every tool it has no rule for (gemini / vibe-local — neither
  * prints a model on its pane in any captured frame; copilot and opencode were
- * added by Issue #1912) and for every frame that does not show the chrome it
+ * added by Issue #1912, opencode-v2 by #3443) and for every frame that does not show the chrome it
  * looks for.
  *
  * **Answering null is a correct outcome, not a failure.** tmux keeps a
@@ -842,7 +895,8 @@ function extractModelInfo(cliToolId, captureText) {
             return sameModel(bar.model, notice.model) ? { model: bar.model, effort: notice.effort } : bar;
         }
         case 'opencode':
-            return scanFromEnd(captureText, readOpencodeStepMarker) ?? unknown();
+        case 'opencode-v2':
+            return readOpencodeStepRow(captureText) ?? unknown();
         case 'command-code':
             // Issue #2358. The banner is the only source — hooks carry no model — and
             // bottom-up is the same "last banner wins" rule Claude uses: a relaunch in

package/dist/server/src/lib/detection/status-detector.js

@@ -76,7 +76,7 @@ exports.SELECTION_LIST_REASONS = new Set([
  * The `running` reasons that mean "the agent is producing output right now"
  * (Issue #1912).
  *
- * `current-output-builder` derives `thinking` / `isGenerating` from this, and it
+ * `current-output-builder` derives `thinking` from this, and it
  * was a single `=== THINKING_INDICATOR` comparison until opencode grew a second
  * one: branch A of the opencode block answers `opencode_processing_indicator`
  * for the footer that reads `esc interrupt`, which is opencode's ONLY signal

package/dist/server/src/lib/git/git-exec.js

@@ -60,13 +60,33 @@ async function execGitCommand(args, cwd) {
     }
     catch (error) {
         // Log error server-side only (no client exposure)
-        logger.error('git:command-failed', {
+        const fields = {
             args: args.join(' '),
+            worktree: path_1.default.basename(cwd),
             error: error instanceof Error ? error.message : 'Unknown error',
-        });
+        };
+        // Issue #3416: a read killed by the 1s timeout is an EXPECTED outcome on a
+        // loaded host (callers already degrade null to '(unknown)' / not dirty), so
+        // it is a warn. Any other failure (git exited non-zero) stays an ERROR.
+        if (isExecTimeout(error)) {
+            logger.warn('git:command-failed', { ...fields, timedOut: true, timeoutMs: GIT_COMMAND_TIMEOUT_MS });
+        }
+        else {
+            logger.error('git:command-failed', fields);
+        }
         return null;
     }
 }
+/**
+ * True when execFile rejected because the child was killed by `timeout`
+ * (Node sets `killed` and leaves stderr empty) rather than because git failed.
+ */
+function isExecTimeout(error) {
+    const err = error;
+    return (err?.killed === true ||
+        err?.code === 'ERR_CHILD_PROCESS_EXEC_TIMEOUT' ||
+        err?.code === 'ETIMEDOUT');
+}
 /**
  * Execute a READ-ONLY git command like {@link execGitCommand} (never throws,
  * same default 1s timeout) but return the stderr alongside the outcome instead
@@ -92,9 +112,7 @@ async function execGitCommandCapture(args, cwd, timeout = GIT_COMMAND_TIMEOUT_MS
     }
     catch (error) {
         const err = error;
-        const timedOut = err.killed === true ||
-            err.code === 'ERR_CHILD_PROCESS_EXEC_TIMEOUT' ||
-            err.code === 'ETIMEDOUT';
+        const timedOut = isExecTimeout(err);
         return {
             ok: false,
             stdout: '',

package/dist/server/src/lib/hooks/sources/claude/self-resume.js

@@ -0,0 +1,213 @@
+"use strict";
+/**
+ * Whether a Claude Code `Stop` leaves background work behind that will wake the
+ * agent again (Issue #3430) — the Claude half of #2614.
+ *
+ * Claude Code ends a turn with work still running in two measured ways: a
+ * `Bash` call that outlived its timeout (or was started with
+ * `run_in_background`) and a `Monitor`. When that work finishes Claude queues a
+ * `<task-notification>` and, if the session is idle, opens a new turn on it by
+ * itself. Measured on 2026-10-08 (worktree commandmate-issue-3423): a worker
+ * ended its turn at 23:37:53 "waiting for the related-tests run to finish",
+ * `wait --verify` read that `Stop` as the end and verified an uncommitted
+ * worktree, and the notification opened the turn that committed at 23:38:32.
+ *
+ * ## What is read, and why not the `Stop` payload
+ *
+ * The payload carries `background_tasks`, but only its empty form has ever been
+ * captured (`tests/fixtures/hooks/claude/stop.json`), so its shape is a guess.
+ * The transcript names the same work in structured fields, measured on the
+ * transcripts under `~/.claude/projects` written in the four days to 2026-10-08:
+ *
+ *  - a background `Bash`: `toolUseResult.backgroundTaskId` (1,008 results);
+ *  - a `Monitor`: `toolUseResult.taskId` beside a boolean `persistent`
+ *    (115 results);
+ *  - a background subagent: `toolUseResult.isAsync: true` and `agentId`
+ *    (30 results);
+ *  - a `TaskStop`: `toolUseResult.task_id` (39 results). A stopped task is never
+ *    notified, so this is what retires it.
+ *
+ * and each finished task is retired by the notification Claude delivers for it:
+ * a `type: "user"` prompt or a `queued_command` attachment whose text begins
+ * with `<task-notification>` and carries `<task-id>…</task-id>` — the id above.
+ * A notice that is only enqueued is not yet delivered, and the session will open
+ * a turn on it, so its task still counts as pending.
+ *
+ * ## Erring towards "finished"
+ *
+ * Every doubt answers "nothing pending", which is what every Claude `Stop` meant
+ * before this Issue: no transcript path, a path outside `~/.claude/projects`, a
+ * file that cannot be read, a line that does not parse. A persistent `Monitor`
+ * (a watch for the whole session, never notified on its own) is not counted
+ * either. A task that really is never notified — a process that died with its
+ * session — is bounded by `commandmate wait`'s `SELF_RESUME_HOLD_MS`.
+ *
+ * @module lib/hooks/sources/claude/self-resume
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLAUDE_SELF_RESUME_TAIL_BYTES = exports.CLAUDE_TRANSCRIPT_PATH_FIELD = void 0;
+exports.pendingClaudeBackgroundTasks = pendingClaudeBackgroundTasks;
+exports.claudeStopLeavesBackgroundWork = claudeStopLeavesBackgroundWork;
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const transcript_history_1 = require("../transcript-history");
+const queued_notice_1 = require("./queued-notice");
+const transcript_1 = require("./transcript");
+/** The `Stop` payload field naming the session's transcript. */
+exports.CLAUDE_TRANSCRIPT_PATH_FIELD = 'transcript_path';
+/**
+ * How much of the transcript's tail is read on a `Stop`.
+ *
+ * A task is started before it is notified, so a window that holds the start
+ * holds the notification too; a start older than the window is simply not seen
+ * (the "finished" direction). 4 MiB is `CLAUDE_TRANSCRIPT_TAIL_BYTES`, the first
+ * read of `./history`, which holds 99% of turns whole (#2470).
+ */
+exports.CLAUDE_SELF_RESUME_TAIL_BYTES = 4 * 1024 * 1024;
+const TASK_ID_PATTERN = /<task-id>([^<]+)<\/task-id>/;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function nonEmptyString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : null;
+}
+/** The background task a tool result started, or null. */
+function startedTaskId(result) {
+    const bash = nonEmptyString(result.backgroundTaskId);
+    if (bash)
+        return bash;
+    // Monitor. `persistent: true` watches for the life of the session and is not
+    // work the turn is waiting on.
+    const monitor = nonEmptyString(result.taskId);
+    if (monitor && result.persistent === false)
+        return monitor;
+    const agent = nonEmptyString(result.agentId);
+    if (agent && result.isAsync === true)
+        return agent;
+    return null;
+}
+/** The task a `<task-notification>` text retires, or null. */
+function notifiedTaskId(text) {
+    if (typeof text !== 'string')
+        return null;
+    if (!text.trimStart().startsWith(queued_notice_1.CLAUDE_TASK_NOTIFICATION_PREFIX))
+        return null;
+    return TASK_ID_PATTERN.exec(text)?.[1] ?? null;
+}
+/** Every text a delivered `type: "user"` record carries. */
+function userTexts(record) {
+    const message = record.message;
+    if (!isRecord(message))
+        return [];
+    const content = message.content;
+    if (typeof content === 'string')
+        return [content];
+    if (!Array.isArray(content))
+        return [];
+    return content.filter(isRecord).filter((b) => b.type === 'text').map((b) => b.text);
+}
+/**
+ * The ids of background tasks started in `text` (transcript JSONL) and not yet
+ * delivered a notification or stopped, in the order they were started.
+ *
+ * Pure. Lines that do not parse are skipped, as is everything a subagent wrote
+ * into the parent's file (`isSidechain: true`).
+ */
+function pendingClaudeBackgroundTasks(text) {
+    const started = [];
+    const retired = new Set();
+    for (const line of text.split('\n')) {
+        if (line.trim() === '')
+            continue;
+        let record;
+        try {
+            record = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (!isRecord(record) || record.isSidechain === true)
+            continue;
+        if (record.type === 'user') {
+            const result = record.toolUseResult;
+            if (isRecord(result)) {
+                const id = startedTaskId(result);
+                if (id)
+                    started.push(id);
+                const stopped = nonEmptyString(result.task_id);
+                if (stopped)
+                    retired.add(stopped);
+            }
+            for (const t of userTexts(record)) {
+                const id = notifiedTaskId(t);
+                if (id)
+                    retired.add(id);
+            }
+        }
+        else if (record.type === 'attachment' && isRecord(record.attachment)) {
+            if (record.attachment.type !== 'queued_command')
+                continue;
+            const id = notifiedTaskId(record.attachment.prompt);
+            if (id)
+                retired.add(id);
+        }
+    }
+    return [...new Set(started)].filter((id) => !retired.has(id));
+}
+/**
+ * The last `maxBytes` of a file, starting at a line boundary; null when it
+ * cannot be read.
+ */
+function readTail(path, maxBytes) {
+    let fd = null;
+    try {
+        fd = (0, fs_1.openSync)(path, 'r');
+        const size = (0, fs_1.fstatSync)(fd).size;
+        const start = Math.max(0, size - maxBytes);
+        const buffer = Buffer.alloc(size - start);
+        let read = 0;
+        while (read < buffer.length) {
+            const n = (0, fs_1.readSync)(fd, buffer, read, buffer.length - read, start + read);
+            if (n === 0)
+                break;
+            read += n;
+        }
+        const text = buffer.subarray(0, read).toString('utf8');
+        // A window opened mid-file starts mid-line; that line is dropped.
+        return start === 0 ? text : text.slice(text.indexOf('\n') + 1);
+    }
+    catch {
+        return null;
+    }
+    finally {
+        if (fd !== null) {
+            try {
+                (0, fs_1.closeSync)(fd);
+            }
+            catch {
+                // Nothing to do: the answer is already decided.
+            }
+        }
+    }
+}
+/**
+ * Whether this `Stop` payload's session still has background work that has not
+ * been notified — i.e. whether Claude will open another turn by itself.
+ *
+ * Synchronous: it runs inside event normalization. `false` for every case it
+ * cannot vouch for (see the module comment).
+ */
+function claudeStopLeavesBackgroundWork(payload, options = {}) {
+    const hint = nonEmptyString(payload[exports.CLAUDE_TRANSCRIPT_PATH_FIELD]);
+    if (!hint)
+        return false;
+    const root = (0, path_1.join)(options.homeDir ?? (0, os_1.homedir)(), ...transcript_1.CLAUDE_PROJECTS_DIR_SEGMENTS);
+    const path = (0, transcript_history_1.acceptPathUnderRoot)(root, '.jsonl', hint);
+    if (!path)
+        return false;
+    const text = readTail(path, options.tailBytes ?? exports.CLAUDE_SELF_RESUME_TAIL_BYTES);
+    if (text === null)
+        return false;
+    return pendingClaudeBackgroundTasks(text).length > 0;
+}

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

@@ -34,6 +34,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.claudeAgentEventSource = void 0;
 exports.encodeClaudeVerdict = encodeClaudeVerdict;
+exports.extractClaudeEventDetail = extractClaudeEventDetail;
 const uat_isolation_1 = require("../../../../config/uat-isolation");
 const agent_event_types_1 = require("../../../../lib/hooks/agent-event-types");
 const ask_user_question_payload_1 = require("../../../../lib/hooks/ask-user-question-payload");
@@ -44,6 +45,7 @@ const event_mapper_1 = require("../event-mapper");
 const hook_event_vocabulary_1 = require("../hook-event-vocabulary");
 const model_switch_1 = require("./model-switch");
 const queued_notice_1 = require("./queued-notice");
+const self_resume_1 = require("./self-resume");
 const tool_id_1 = require("./tool-id");
 /**
  * The no-decision body, byte for byte what the #1721 spike returned for D5.
@@ -85,6 +87,20 @@ function encodeClaudeVerdict(verdict) {
         },
     };
 }
+/**
+ * The subtype of one Claude event.
+ *
+ * Every event but `stop` is the shared snake_case reading (S2). A `stop` is
+ * {@link SELF_RESUME_PENDING_DETAIL} when the session's transcript shows
+ * background work that has not been notified yet (Issue #3430), and has no
+ * subtype otherwise — which is what every Claude `stop` had before.
+ */
+function extractClaudeEventDetail(event, payload) {
+    if (event === 'stop' && (0, self_resume_1.claudeStopLeavesBackgroundWork)(payload)) {
+        return agent_event_types_1.SELF_RESUME_PENDING_DETAIL;
+    }
+    return (0, hook_event_vocabulary_1.extractSnakeCaseEventDetail)(event, payload);
+}
 /**
  * Claude Code as an event source.
  *
@@ -127,11 +143,12 @@ exports.claudeAgentEventSource = (0, define_source_1.definePushHookSource)({
         // JSONL when the poller asks (#2121); the gate dispatches on this word
         // rather than on the tool id.
         transcriptHistory: 'pull',
-        // Issue #2614. Claude Code does resume itself (background tasks, session
-        // crons), and its `Stop` payload carries `background_tasks` /
-        // `session_crons` — but only the empty form has been captured, so nothing
-        // reads them yet and this stays false until a non-empty one is measured.
-        stopReportsSelfResume: false,
+        // Issue #3430 (#2614 for Claude). A `Stop` whose transcript shows a
+        // background `Bash` / `Monitor` / subagent not yet notified carries
+        // `SELF_RESUME_PENDING_DETAIL`: the notification opens the next turn by
+        // itself. The payload's `background_tasks` is still unread — only its empty
+        // form has been captured. See `./self-resume` and `extractDetail` below.
+        stopReportsSelfResume: true,
     },
     // S1. A plain name table is enough *for this tool* — one native name, one
     // word, no predicates — so it is expressed as rules built from the table
@@ -163,8 +180,8 @@ exports.claudeAgentEventSource = (0, define_source_1.definePushHookSource)({
     // Issue #3330. A background-task notice attached to the running turn fires
     // `UserPromptSubmit` too, and continues that turn rather than opening one.
     promptJoinsOpenTurn: queued_notice_1.isClaudeQueuedNoticePrompt,
-    // S2.
-    extractDetail: hook_event_vocabulary_1.extractSnakeCaseEventDetail,
+    // S2, plus the `Stop` that leaves background work behind (Issue #3430).
+    extractDetail: extractClaudeEventDetail,
     // S7. Both parsers are strict and answer null for anything they cannot vouch
     // for; the callers turn null into "no structured data", which degrades to the
     // behaviour of a machine without hooks rather than into a guess.

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

@@ -322,8 +322,8 @@ function shortSessionTag(sessionId) {
 /**
  * Forget every `stop` one session of one instance has claimed (Issue #3289).
  *
- * Every subtype: antigravity posts `stop` / `self_resume_pending` (#2614)
- * beside the plain one.
+ * Every subtype: antigravity (#2614) and claude (#3430) post `stop` /
+ * `self_resume_pending` beside the plain one.
  */
 function releaseStopClaims(composite, sessionId) {
     releaseClaims(composite, ['stop'], sessionId);

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

@@ -39,7 +39,7 @@
  * @module lib/session/agent-event-state
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.STRUCTURED_PROMPT_PROVISIONAL_MAX_AGE_MS = exports.recordAskUserQuestion = exports.getAskUserQuestion = exports.clearAskUserQuestion = exports.isAwaitingInstruction = exports.getAwaitingInstruction = exports.STRUCTURED_STATE_MAX_AGE_MS = exports.getStructuredSessionState = exports.observeScraperCompletionEvidence = exports.joinOpenTurnFromDuplicate = exports.getPublishedAgentTurn = exports.getPendingDecisions = exports.getAgentTurn = exports.closeAgentTurn = exports.recordCapturedModelInfo = exports.recordAgentReportedModel = exports.recordAgentReportedEffort = exports.onAgentModelChange = exports.isSameAgentModelName = exports.getResolvedAgentModelInfo = exports.getLastReportedAgentEffort = exports.getLastKnownAgentModel = exports.getLastKnownAgentEffort = exports.getLastCapturedModelInfo = exports.getAgentModelBaseline = exports.AGENT_MODEL_EFFORT_SUFFIX_PATTERN = exports.shortSessionTag = exports.LIFECYCLE_AGENT_EVENT_TYPES = exports.isDuplicateAgentEvent = exports.getRecentEventKeyCount = exports.getRecentEventIdentityCount = exports.getAgentEventDropCounts = exports.classifyAgentEventDelivery = exports.agentEventKeyClaimedAt = exports.AGENT_EVENT_DEDUP_WINDOW_MS = void 0;
+exports.STRUCTURED_PROMPT_PROVISIONAL_MAX_AGE_MS = exports.recordAskUserQuestion = exports.getAskUserQuestion = exports.clearAskUserQuestion = exports.isAwaitingInstruction = exports.getAwaitingInstruction = exports.STRUCTURED_STATE_MAX_AGE_MS = exports.getStructuredSessionState = exports.observeScraperCompletionEvidence = exports.joinOpenTurnFromDuplicate = exports.isPreToolUseOutsideTurn = exports.getPublishedAgentTurn = exports.getPendingDecisions = exports.getAgentTurn = exports.closeAgentTurn = exports.recordCapturedModelInfo = exports.recordAgentReportedModel = exports.recordAgentReportedEffort = exports.onAgentModelChange = exports.isSameAgentModelName = exports.getResolvedAgentModelInfo = exports.getLastReportedAgentEffort = exports.getLastKnownAgentModel = exports.getLastKnownAgentEffort = exports.getLastCapturedModelInfo = exports.getAgentModelBaseline = exports.AGENT_MODEL_EFFORT_SUFFIX_PATTERN = exports.shortSessionTag = exports.LIFECYCLE_AGENT_EVENT_TYPES = exports.isDuplicateAgentEvent = exports.getRecentEventKeyCount = exports.getRecentEventIdentityCount = exports.getAgentEventDropCounts = exports.classifyAgentEventDelivery = exports.agentEventKeyClaimedAt = exports.AGENT_EVENT_DEDUP_WINDOW_MS = void 0;
 exports.recordAgentStopEvent = recordAgentStopEvent;
 exports.getLastStopEventAt = getLastStopEventAt;
 exports.recordAgentEvent = recordAgentEvent;
@@ -92,6 +92,7 @@ Object.defineProperty(exports, "closeAgentTurn", { enumerable: true, get: functi
 Object.defineProperty(exports, "getAgentTurn", { enumerable: true, get: function () { return agent_event_turn_2.getAgentTurn; } });
 Object.defineProperty(exports, "getPendingDecisions", { enumerable: true, get: function () { return agent_event_turn_2.getPendingDecisions; } });
 Object.defineProperty(exports, "getPublishedAgentTurn", { enumerable: true, get: function () { return agent_event_turn_2.getPublishedAgentTurn; } });
+Object.defineProperty(exports, "isPreToolUseOutsideTurn", { enumerable: true, get: function () { return agent_event_turn_2.isPreToolUseOutsideTurn; } });
 Object.defineProperty(exports, "joinOpenTurnFromDuplicate", { enumerable: true, get: function () { return agent_event_turn_2.joinOpenTurnFromDuplicate; } });
 Object.defineProperty(exports, "observeScraperCompletionEvidence", { enumerable: true, get: function () { return agent_event_turn_2.observeScraperCompletionEvidence; } });
 var agent_event_structured_state_2 = require("../../lib/session/agent-event-structured-state");

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

@@ -20,6 +20,7 @@ exports.closeAgentTurn = closeAgentTurn;
 exports.observeScraperCompletionEvidence = observeScraperCompletionEvidence;
 exports.fenceTurnForNewGeneration = fenceTurnForNewGeneration;
 exports.applyTurnTransition = applyTurnTransition;
+exports.isPreToolUseOutsideTurn = isPreToolUseOutsideTurn;
 exports.joinOpenTurnFromDuplicate = joinOpenTurnFromDuplicate;
 exports.openDecision = openDecision;
 exports.releaseAllDecisions = releaseAllDecisions;
@@ -313,6 +314,7 @@ function fenceTurnForNewGeneration(key, at) {
  * | `user_prompt_submit`               | **opens a new one**     | release  | yes     |
  * | `user_prompt_submit` (joins, #3330)| continues, else opens   | release  | yes     |
  * | `pre_tool_use`                     | continues, else opens   | unchanged| yes     |
+ * | `pre_tool_use` (after its stop)    | unchanged (#3437)       | unchanged| no      |
  * | `post_tool_use`                    | continues, else opens   | release  | yes     |
  * | `stop` (this session)              | **closes** `stop`       | release  | yes     |
  * | `stop` (another session)           | unchanged               | unchanged| no      |
@@ -377,6 +379,22 @@ function fenceTurnForNewGeneration(key, at) {
  * still dropped by the window in front of it ({@link isDuplicateAgentEvent}),
  * and dropped or applied, none of them moves the turn.
  *
+ * The `after its stop` row is the other exception (Issue #3437), and it is
+ * narrower than it reads: it applies only to a source that reports its
+ * prompts ({@link AgentEventRecord.promptOpensTurns}), and only when the
+ * instance's last turn was closed by the agent's own `stop`. In production on
+ * 2026-10-07 a Claude `PreToolUse(AskUserQuestion)` landed 2.5 s after the
+ * `Stop`, with no `UserPromptSubmit`, no picker on the pane (the scraper read
+ * `ready` throughout), and nothing in the session's transcript after the
+ * `Stop` — something other than the conversation the `Stop` had just ended.
+ * It opened a turn whose `stop` never came, and a `wait` adopted that turn.
+ * Every turn of such a source begins with its prompt, and a tool call that
+ * continues past a `Stop` (a Stop hook that blocks) still reports its
+ * `post_tool_use`, which opens the turn as before. Sources whose turns begin
+ * with a tool event are untouched: Command Code's `pre_tool_use` and
+ * antigravity's self-resume `post_tool_use` (#2614) open turns because
+ * neither sends `user_prompt_submit`.
+ *
  * `idle_prompt` is the one row that publishes `ready` **without** closing the
  * turn, and that is a measurement rather than an oversight: #1839 caught Claude
  * emitting it 62 s into a turn that ran nothing, so it cannot be a turn
@@ -409,6 +427,12 @@ function applyTurnTransition(key, record) {
             // Deliberately leaves the dialog alone (Issue #1726). It is the
             // `AskUserQuestion` invocation, and a picker being *about to be drawn* is
             // not a fact this state can carry.
+            //
+            // Issue #3437: and from a source that reports its prompts, it is not the
+            // start of a turn when the agent's own `Stop` is the last thing that
+            // ended one. See the `after its stop` row above.
+            if (record.promptOpensTurns === true && endedByOwnStop(key))
+                return;
             openTurn(key, record, generation, { continueOpen: true });
             return;
         case 'stop':
@@ -432,6 +456,33 @@ function applyTurnTransition(key, record) {
             return;
     }
 }
+/**
+ * Whether this instance's turn was last ended by the agent's own `stop`, with
+ * nothing opening a turn since (Issue #3437).
+ *
+ * Only `stop`: every other close is this server's own inference (`stale`,
+ * `scraper_evidence`, `resync_idle`) or a session that went away
+ * (`session_end`, `generation`), and an agent that keeps working after one of
+ * those must be allowed to open the turn it is in.
+ */
+function endedByOwnStop(key) {
+    const turn = fencedTurn(key);
+    return turn !== null && turn.closedAt !== null && turn.closedBy === 'stop';
+}
+/**
+ * Whether a `pre_tool_use` from a source that reports its prompts falls outside
+ * any turn: the instance's last turn was ended by the agent's own `stop` and
+ * nothing has opened one since (Issue #3446).
+ *
+ * The same reading {@link applyTurnTransition} uses to leave such an event's
+ * turn closed (#3437), exposed so the intake can decide the question that event
+ * carries on the same facts. Asked after the event was applied, it still holds,
+ * because the transition did not open a turn; for a source that does not report
+ * its prompts it is always false, because that event opened one.
+ */
+function isPreToolUseOutsideTurn(worktreeId, cliToolId, instanceId, promptOpensTurns) {
+    return promptOpensTurns && endedByOwnStop((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId));
+}
 /** The three fields the turn keeps from a record. */
 function displayOf(record) {
     return { event: record.event, at: record.at, detail: record.detail };

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

@@ -479,12 +479,7 @@ function buildRunningPayload({ worktreeId, cliToolId, instanceId, sessionName, p
         realtimeSnippet,
         lineCount: totalLines,
         lastCapturedLine,
-        isComplete: isPromptWaiting,
-        isGenerating: published.thinking,
         thinking: published.thinking,
-        // Issue #2607: named after the tool actually running. A fixed "Claude" was
-        // published for every agent, and `capture --json` readers took it at its word.
-        thinkingMessage: published.thinking ? `${(0, types_1.getCliToolDisplayName)(cliToolId)} is thinking...` : null,
         isPromptWaiting,
         promptData,
         ...(promptAnswerable !== undefined ? { promptAnswerable } : {}),

package/dist/server/src/lib/skills/install-plan.js

@@ -496,6 +496,7 @@ async function createSkillInstallPlan(input) {
             headState: git.headState,
             headCommit: git.headCommit,
             workingTreeDirty: git.dirty,
+            ...(git.dirtyUnknown ? { workingTreeUnknown: true } : {}),
             installRoot: primary.preview.installRoot,
             installRoots,
             currentTreeHash: primary.preview.currentTreeHash,

package/dist/server/src/lib/skills/preview-diff.js

@@ -37,6 +37,7 @@ exports.readSkillGitTargetState = readSkillGitTargetState;
 exports.findGitIgnoredPaths = findGitIgnoredPaths;
 exports.buildUnifiedDiff = buildUnifiedDiff;
 exports.buildSkillPreviewDiff = buildSkillPreviewDiff;
+exports.workingTreeWarning = workingTreeWarning;
 const crypto_1 = require("crypto");
 const fs_1 = require("fs");
 const path_1 = __importDefault(require("path"));
@@ -88,6 +89,8 @@ exports.SkillPreviewWarning = {
     HEAD_UNRESOLVED: 'SKILL_PREVIEW_HEAD_UNRESOLVED',
     /** The worktree has uncommitted changes. */
     WORKING_TREE_DIRTY: 'SKILL_PREVIEW_WORKING_TREE_DIRTY',
+    /** `git status` could not be read, so uncommitted changes may exist (Issue #3445). */
+    WORKING_TREE_STATUS_UNKNOWN: 'SKILL_PREVIEW_WORKING_TREE_STATUS_UNKNOWN',
     /** At least one destination path is ignored or excluded by git. */
     PATH_GIT_IGNORED: 'SKILL_PREVIEW_PATH_GIT_IGNORED',
     /** At least one diff body was cut short. */
@@ -338,7 +341,13 @@ async function readSkillGitTargetState(worktreePath) {
         headState,
         branch: branch && branch.length > 0 ? branch : null,
         headCommit: commit,
-        dirty: status !== null && status.length > 0,
+        // Issue #3435: an unread `status` (null, e.g. the 1s timeout) must not
+        // read as clean. This flag only drives the advisory WORKING_TREE_DIRTY
+        // warning and the target display, so the fail-safe side is "dirty".
+        dirty: status === null || status.length > 0,
+        // Issue #3445: say the guess is a guess, so the display can tell "has
+        // changes" from "could not check". Absent on success (shape unchanged).
+        ...(status === null ? { dirtyUnknown: true } : {}),
     };
 }
 /**
@@ -603,6 +612,17 @@ function buildSkillPreviewDiff(input) {
         plannedTreeHash: computeSkillTreeHash(plannedTree),
     };
 }
+/**
+ * The working-tree caveat for a target (Issue #3445): an unread status is still
+ * a caveat (fail-safe), but worded as "could not check" rather than "dirty".
+ */
+function workingTreeWarning(git) {
+    if (git.dirtyUnknown)
+        return exports.SkillPreviewWarning.WORKING_TREE_STATUS_UNKNOWN;
+    if (git.dirty)
+        return exports.SkillPreviewWarning.WORKING_TREE_DIRTY;
+    return null;
+}
 function collectWarnings(input, entries, stats, anyCrlf) {
     const warnings = [];
     if (input.git.headState === 'detached')
@@ -611,8 +631,9 @@ function collectWarnings(input, entries, stats, anyCrlf) {
         warnings.push(exports.SkillPreviewWarning.UNBORN_HEAD);
     if (input.git.headState === 'unknown')
         warnings.push(exports.SkillPreviewWarning.HEAD_UNRESOLVED);
-    if (input.git.dirty)
-        warnings.push(exports.SkillPreviewWarning.WORKING_TREE_DIRTY);
+    const dirtyWarning = workingTreeWarning(input.git);
+    if (dirtyWarning)
+        warnings.push(dirtyWarning);
     if (entries.some((entry) => entry.gitIgnored))
         warnings.push(exports.SkillPreviewWarning.PATH_GIT_IGNORED);
     if (stats.truncatedFiles > 0)

package/dist/server/src/lib/skills/uninstall-plan.js

@@ -419,6 +419,7 @@ function createSkillUninstallPlan(input) {
             headState: input.git.headState,
             headCommit: input.git.headCommit,
             workingTreeDirty: input.git.dirty,
+            ...(input.git.dirtyUnknown ? { workingTreeUnknown: true } : {}),
             installRoot: assessment.installRoot,
             currentTreeHash: assessment.currentTreeHash,
         },