commandmate 0.44.3 → 0.45.1

package/dist/server/src/lib/auto-yes-poller.js

@@ -7,8 +7,9 @@
  *
  * Issue #525: Composite key migration (worktreeId:cliToolId) for per-agent auto-yes.
  *
- * Dependencies: auto-yes-state.ts (one-way dependency).
- * auto-yes-poller.ts -> auto-yes-state.ts
+ * Dependencies: auto-yes-state.ts (composite keys / state), polling/* (prompt
+ * detection, resolver, policy, dialog gate, enter fallback, poller state),
+ * cli-tools/*, session/cli-session.ts, tmux/*, detection/*, db/*, tasks/*.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -67,7 +68,6 @@ const auto_yes_resolver_1 = require("./polling/auto-yes-resolver");
 const auto_yes_policy_1 = require("./polling/auto-yes-policy");
 const detect_1 = require("./detection/tools/codex/detect");
 const frame_1 = require("./detection/tools/frame");
-const auto_yes_suppression_state_1 = require("./polling/auto-yes-suppression-state");
 const auto_yes_dialog_gate_1 = require("./polling/auto-yes-dialog-gate");
 const auto_yes_enter_fallback_1 = require("./polling/auto-yes-enter-fallback");
 const task_transition_service_1 = require("./tasks/task-transition-service");
@@ -88,6 +88,8 @@ const logger = (0, logger_1.createLogger)('auto-yes-poller');
 const path_validator_1 = require("./security/path-validator");
 const auto_yes_state_1 = require("./auto-yes-state");
 const global_state_1 = require("./global-state");
+const auto_yes_poller_state_1 = require("./polling/auto-yes-poller-state");
+const auto_yes_prompt_suppression_1 = require("./polling/auto-yes-prompt-suppression");
 /** In-memory storage for poller states (globalThis for hot reload persistence) */
 const autoYesPollerStates = (0, global_state_1.getOrInitGlobal)('__autoYesPollerStates', () => new Map());
 /**
@@ -221,45 +223,6 @@ function isDuplicatePrompt(pollerState, promptKey) {
         return false;
     return (Date.now() - pollerState.lastAnsweredAt) < auto_yes_state_1.DUPLICATE_RETRY_EXPIRY_MS;
 }
-/**
- * Issue #2995: print a "did not answer" line as WARN once per frame.
- *
- * The poller re-reads a static pane every 2s, so a frame Auto-Yes leaves alone
- * (a reply quoting `1. Yes / 2. No`, a launch dialog, a policy-withheld prompt,
- * a foreign session) would otherwise print the same WARN on every tick. The
- * first one stays WARN -- it is what tells a silently stalled worker apart --
- * and repeats for the same frame drop to `debug`. The frame is identified by
- * the event, `promptFrameKey()` and the event's own detail; a different
- * prompt, a different reason, or a tick with no prompt / an answer sent (both
- * clear the key) makes the next line WARN again.
- * `recordPolicySuppression()` is not throttled: `capture --json` and `wait`
- * read the latest record, not the log.
- */
-/**
- * Issue #2995: what makes two ticks "the same prompt" for `warnOncePerFrame`.
- *
- * `generatePromptKey` alone is type + question, and the question the detector
- * extracts from an agent's reply is often a fixed line above the list, so two
- * different lists would share it. The option rows (and where the cursor sits)
- * plus `approvalTarget` -- the current prompt's own panel, which leaves out
- * scrollback and footers that change while the prompt does not -- separate them.
- * Not the whole pane: a status bar that ticks every second would defeat it.
- */
-function promptFrameKey(promptData) {
-    const options = promptData.type === 'multiple_choice'
-        ? promptData.options.map((o) => `${o.isDefault ? '>' : ''}${o.number}.${o.label}`).join('\n')
-        : '';
-    return [(0, prompt_key_1.generatePromptKey)(promptData), options, promptData.approvalTarget ?? ''].join('\u0000');
-}
-function warnOncePerFrame(pollerState, frameKey, event, fields) {
-    const key = `${event}\u0000${frameKey}`;
-    if (pollerState.lastSkipWarnKey === key) {
-        logger.debug(event, { ...fields, repeated: true });
-        return;
-    }
-    pollerState.lastSkipWarnKey = key;
-    logger.warn(event, fields);
-}
 // =============================================================================
 // Extracted Functions for pollAutoYes (Issue #323: SRP decomposition)
 // =============================================================================
@@ -395,116 +358,6 @@ function logIfWithheldForWantOfReceipt(worktreeId, instanceId, compositeKey, rea
         hint: 'hook の受信記録が直近に無いため Auto-Yes は答えなかった。~/.gemini/config/hooks.json の向き先（#2622）を確認',
     });
 }
-/**
- * Issue #3214: the form the four suppression exits of `detectAndRespondToPrompt`
- * share. Records why Auto-Yes left the prompt alone (`recordPolicySuppression`,
- * not throttled), then prints the WARN once per frame (`warnOncePerFrame`).
- *
- * @param suppression - Handed to `recordPolicySuppression` as is
- * @param warnFrameKey - Handed to `warnOncePerFrame` as is: the prompt's
- *   `frameKey` plus the exit's own detail
- * @param event - The WARN's log name
- * @param detail - The WARN's fields after `worktreeId`, `cliToolId` and `instanceId`
- */
-function suppressAndWarnOnce(prompt, suppression, warnFrameKey, event, detail) {
-    const { worktreeId, cliToolId, instanceId } = prompt;
-    (0, auto_yes_suppression_state_1.recordPolicySuppression)(worktreeId, cliToolId, instanceId, suppression);
-    warnOncePerFrame(prompt.pollerState, warnFrameKey, event, {
-        worktreeId,
-        cliToolId,
-        instanceId,
-        ...detail,
-    });
-}
-/**
- * Issue #3214: steps 3, 3.2 and 3.5 of `detectAndRespondToPrompt` -- the frames
- * that read as a prompt and are still not Auto-Yes's to answer, judged in the
- * order they always were. "The detection above" in the comments below is that
- * function's step 1.
- *
- * Issue #3397: step 3.5 no longer records its refusal here. It hands the gate's
- * verdict back so `tryEnterFallback` can look at the frame first, and records
- * through {@link suppressUnclassifiedFrame} when that sends nothing. Steps 3 and
- * 3.2 still win: an Enter never reaches codex's launch dialogs or its `/model`
- * picker.
- *
- * @param frame - The tick's one normalised frame (Issue #3183)
- */
-function suppressIfNotOursToAnswer(prompt, frame) {
-    const { cliToolId, promptData, frameKey } = prompt;
-    // 3. Issue #1829: codex's own launch dialogs are CodexTool.waitForReady()'s
-    // to answer, not the poller's. Every one of them defaults to option 1, and
-    // the base rules answer the default:
-    //
-    //   "Hooks need review"  -> 1. Review hooks   (undoes Issue #1760; the pane
-    //                           then sits two screens deep in a review UI that
-    //                           only `t`/`esc` leave, reported as `running`)
-    //   "Update available"   -> 1. Update now     (undoes Issue #890; runs
-    //                           `npm install -g @openai/codex`, killing codex)
-    //   "Do you trust …"     -> 1. Yes, continue
-    //
-    // waitForReady answers the same screens deliberately and differently ('3',
-    // '2', '1' — each without a trailing Enter), but only during startSession,
-    // while this poller runs on its own 2s phase for the life of the session.
-    // Whichever sees the dialog first decides, so the fix is to leave them all
-    // to the tool. Auto-answer layer only: the detection above still reports the
-    // prompt, so the human keeps seeing the screen and the response poller
-    // still notifies them about it.
-    const launchDialog = cliToolId === 'codex' ? (0, cli_patterns_1.getCodexLifecycleDialog)(frame) : null;
-    if (launchDialog) {
-        // Recorded through the #1684 channel so `capture --json` and `cmate wait`
-        // can name the reason instead of showing a worker that went quiet.
-        suppressAndWarnOnce(prompt, { reason: 'agent-launch-dialog', mode: null, promptType: promptData.type }, `${frameKey}\u0000${launchDialog}`, 'poller:auto-yes-skipped-launch-dialog', { dialog: launchDialog, promptType: promptData.type });
-        return { kind: 'left-alone' };
-    }
-    // 3.2. Issue #3062: codex's `/model` picker (both stages) is not ours to
-    // answer. A digit there is an immediate decision, so the base rules'
-    // default would choose the model and effort for the operator. Judged by the
-    // picker's own footer, not by `kind: picker`, which the hooks screens share.
-    // The tool's `detectPrompt` still reports the prompt, so `/prompt-response`
-    // (the human's answer) is unaffected. Reuses `unclassified-frame`: the tool
-    // recognised the frame and deliberately declined it.
-    if (cliToolId === 'codex' && (0, detect_1.isCodexModelPickerFrame)(frame)) {
-        suppressAndWarnOnce(prompt, { reason: 'unclassified-frame', mode: null, promptType: promptData.type }, `${frameKey}\u0000codex-model-picker`, 'poller:auto-yes-skipped-model-picker', { promptType: promptData.type });
-        return { kind: 'left-alone' };
-    }
-    // 3.5. Issue #1928 (§4 D1 decision 4): the generic numbered-list inference is
-    // not enough to send an answer. The detection above judges the ROWS, and the
-    // rows of an agent's own reply can be indistinguishable from a dialog's --
-    // opencode 1.18 answering "list three options and ask which one" is the
-    // reported case (#1896), and the `1` this poller sent in reply was not
-    // answering anything, it was SENT AS A USER UTTERANCE. What separates the two
-    // is position and chrome, which only the tool's own module knows, so the
-    // decision is delegated to `detectDialog` (the seam #1927 declared).
-    //
-    // Per tool, and only for tools whose dialogs were measured from their own
-    // live captures -- see AUTO_YES_DIALOG_GATE_DEFAULT_MODE. An ungated tool
-    // reaches `allowed: true` without being judged, which is the pre-#1928
-    // behaviour and the right one where nobody has measured anything.
-    //
-    // Recorded through the #1684 channel with the reason code #1924 landed for
-    // exactly this position, so `capture --json` and `cmate wait` can name the
-    // gap instead of showing a worker that silently went quiet.
-    const dialogGate = (0, auto_yes_dialog_gate_1.evaluateAutoYesDialogGate)(cliToolId, promptData.type, frame);
-    if (!dialogGate.allowed) {
-        return { kind: 'dialog-gate-refused', dialogGate };
-    }
-    return { kind: 'ours' };
-}
-/**
- * Step 3.5's record: the tool's dialog detector did not vouch for the frame and
- * nothing was sent (Issue #1928). Split out of `suppressIfNotOursToAnswer` by
- * Issue #3397, unchanged, so it runs after `tryEnterFallback` declined.
- */
-function suppressUnclassifiedFrame(prompt, dialogGate) {
-    const { promptData, frameKey } = prompt;
-    suppressAndWarnOnce(prompt, { reason: 'unclassified-frame', mode: null, promptType: promptData.type }, `${frameKey}\u0000${dialogGate.dialog?.kind ?? ''}\u0000${dialogGate.mode}`, 'poller:auto-yes-skipped-unclassified-frame', {
-        promptType: promptData.type,
-        dialogKind: dialogGate.dialog?.kind ?? null,
-        answerMode: dialogGate.dialog?.answerMode ?? null,
-        gateMode: dialogGate.mode,
-    });
-}
 /**
  * The audit row's `answer` for the Enter (Issue #3397): not a digit, so the
  * History reads as "Auto-Yes pressed Enter" rather than as a chosen option.
@@ -525,7 +378,7 @@ function isStillEnterFallbackScreen(prompt, fresh) {
     const detection = (0, response_checker_1.detectPromptOnCleanFrame)(clean, cliToolId, clean.split('\n'), fresh, { worktreeId, instanceId }, frame);
     if (!detection.isPrompt || !detection.promptData)
         return false;
-    if (promptFrameKey(detection.promptData) !== frameKey)
+    if ((0, auto_yes_poller_state_1.promptFrameKey)(detection.promptData) !== frameKey)
         return false;
     if (cliToolId === 'codex' && ((0, cli_patterns_1.getCodexLifecycleDialog)(frame) || (0, detect_1.isCodexModelPickerFrame)(frame))) {
         return false;
@@ -563,7 +416,7 @@ async function tryEnterFallback(prompt, promptDetection, dialogGate, rawOutput)
     const judgement = dialogGate.dialog === null ? (0, auto_yes_enter_fallback_1.judgeEnterFallback)(cliToolId, rawOutput) : null;
     if (judgement === null || !judgement.eligible) {
         pollerState.enterFallbackCandidateKey = null;
-        suppressUnclassifiedFrame(prompt, dialogGate);
+        (0, auto_yes_prompt_suppression_1.suppressUnclassifiedFrame)(prompt, dialogGate);
         return false;
     }
     const screenKey = (0, auto_yes_enter_fallback_1.enterFallbackScreenKey)(promptData);
@@ -571,8 +424,8 @@ async function tryEnterFallback(prompt, promptDetection, dialogGate, rawOutput)
     if (pollerState.enterFallbackSentKey === frameKey) {
         pollerState.enterFallbackCandidateKey = null;
         (0, auto_yes_enter_fallback_1.recordEnterFallbackNoEffect)(worktreeId, cliToolId, instanceId, screenKey);
-        suppressUnclassifiedFrame(prompt, dialogGate);
-        warnOncePerFrame(pollerState, `${frameKey}\u0000enter-fallback-no-effect`, 'poller:auto-yes-enter-fallback-no-effect', {
+        (0, auto_yes_prompt_suppression_1.suppressUnclassifiedFrame)(prompt, dialogGate);
+        (0, auto_yes_poller_state_1.warnOncePerFrame)(pollerState, `${frameKey}\u0000enter-fallback-no-effect`, 'poller:auto-yes-enter-fallback-no-effect', {
             worktreeId,
             cliToolId,
             instanceId,
@@ -586,7 +439,7 @@ async function tryEnterFallback(prompt, promptDetection, dialogGate, rawOutput)
     const resolution = (0, auto_yes_resolver_1.resolveAutoAnswerWithPolicy)(promptData, policy);
     if (resolution.suppressedBy) {
         pollerState.enterFallbackCandidateKey = null;
-        suppressAndWarnOnce(prompt, {
+        (0, auto_yes_prompt_suppression_1.suppressAndWarnOnce)(prompt, {
             reason: resolution.suppressedBy,
             mode: policy?.mode ?? null,
             promptType: promptData.type,
@@ -608,7 +461,7 @@ async function tryEnterFallback(prompt, promptDetection, dialogGate, rawOutput)
     if (resolution.answer === null ||
         (promptData.type === 'multiple_choice' && (0, prompt_answer_semantic_1.isMultiSelectPrompt)(promptData))) {
         pollerState.enterFallbackCandidateKey = null;
-        suppressUnclassifiedFrame(prompt, dialogGate);
+        (0, auto_yes_prompt_suppression_1.suppressUnclassifiedFrame)(prompt, dialogGate);
         return false;
     }
     // 4. Seen once: wait for the next tick to see the same screen again.
@@ -629,7 +482,7 @@ async function tryEnterFallback(prompt, promptDetection, dialogGate, rawOutput)
     const sessionName = manager_1.CLIToolManager.getInstance().getTool(cliToolId).getSessionName(worktreeId, instanceId);
     const ownership = await (0, worktree_session_ownership_1.checkWorktreeSessionOwnership)(worktreeId, sessionName);
     if (ownership === null || ownership.verdict === 'foreign') {
-        warnOncePerFrame(pollerState, `${frameKey}\u0000${sessionName}\u0000${ownership ? 'foreign' : 'worktree_not_found'}`, 'poller:auto-yes-skipped-foreign-session', {
+        (0, auto_yes_poller_state_1.warnOncePerFrame)(pollerState, `${frameKey}\u0000${sessionName}\u0000${ownership ? 'foreign' : 'worktree_not_found'}`, 'poller:auto-yes-skipped-foreign-session', {
             worktreeId,
             cliToolId,
             instanceId,
@@ -841,7 +694,7 @@ async function detectAndRespondToPrompt(worktreeId, pollerState, cliToolId, clea
         }
         // 2. Check for duplicate prompt (Issue #306)
         const promptKey = (0, prompt_key_1.generatePromptKey)(promptDetection.promptData);
-        const frameKey = promptFrameKey(promptDetection.promptData);
+        const frameKey = (0, auto_yes_poller_state_1.promptFrameKey)(promptDetection.promptData);
         if (isDuplicatePrompt(pollerState, promptKey)) {
             return 'duplicate';
         }
@@ -857,7 +710,7 @@ async function detectAndRespondToPrompt(worktreeId, pollerState, cliToolId, clea
         };
         // 3., 3.2., 3.5. Frames that are not Auto-Yes's to answer: see
         // `suppressIfNotOursToAnswer`.
-        const notOurs = suppressIfNotOursToAnswer(judged, frame);
+        const notOurs = (0, auto_yes_prompt_suppression_1.suppressIfNotOursToAnswer)(judged, frame);
         if (notOurs.kind !== 'dialog-gate-refused') {
             pollerState.enterFallbackCandidateKey = null;
         }
@@ -883,7 +736,7 @@ async function detectAndRespondToPrompt(worktreeId, pollerState, cliToolId, clea
             // Issue #1684: the log line alone leaves a CLI-driven pipeline blind to
             // why its worker stalled. Record the suppression so buildCurrentOutput
             // can publish it (`autoYes.lastSuppression` in capture --json).
-            suppressAndWarnOnce(judged, {
+            (0, auto_yes_prompt_suppression_1.suppressAndWarnOnce)(judged, {
                 reason: resolution.suppressedBy,
                 mode: policy?.mode ?? null,
                 promptType: promptDetection.promptData.type,
@@ -907,7 +760,7 @@ async function detectAndRespondToPrompt(worktreeId, pollerState, cliToolId, clea
         // server created. The poller keeps running; it just does not type.
         const ownership = await (0, worktree_session_ownership_1.checkWorktreeSessionOwnership)(worktreeId, sessionName);
         if (ownership === null || ownership.verdict === 'foreign') {
-            warnOncePerFrame(pollerState, `${frameKey}\u0000${sessionName}\u0000${ownership ? 'foreign' : 'worktree_not_found'}`, 'poller:auto-yes-skipped-foreign-session', {
+            (0, auto_yes_poller_state_1.warnOncePerFrame)(pollerState, `${frameKey}\u0000${sessionName}\u0000${ownership ? 'foreign' : 'worktree_not_found'}`, 'poller:auto-yes-skipped-foreign-session', {
                 worktreeId,
                 cliToolId,
                 instanceId,

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;
+}