commandmate 0.26.1 → 0.27.1

package/dist/server/src/lib/session/agent-session-lifecycle.js

@@ -54,13 +54,21 @@ const logger = (0, logger_1.createLogger)('lib/session/agent-session-lifecycle')
  * @param at - Epoch ms; defaults to now
  */
 function beginAgentSession(target, at = Date.now()) {
+    const before = (0, agent_event_state_1.getAgentEventDropCounts)(target.worktreeId, target.cliToolId, target.instanceId).decisionEvicted;
     (0, agent_event_state_1.beginAgentEventGeneration)(target.worktreeId, target.cliToolId, target.instanceId, at);
+    const after = (0, agent_event_state_1.getAgentEventDropCounts)(target.worktreeId, target.cliToolId, target.instanceId).decisionEvicted;
     const source = (0, sources_1.getAgentEventSource)(target.cliToolId);
     logger.info('agent-session-generation-begun', {
         worktreeId: target.worktreeId,
         cliToolId: target.cliToolId,
         instanceId: target.instanceId ?? target.cliToolId,
         transport: source.transport,
+        // Issue #1930: approvals the replaced process was holding, discarded with
+        // it. Usually zero. A non-zero count on a *routine* restart is the
+        // interesting case — it says a session was recreated while somebody was
+        // blocked on a dialog, which is a thing an operator would otherwise only
+        // learn by noticing their `respond` no longer has anything to answer.
+        decisionsEvicted: after - before,
     });
 }
 /**

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

@@ -91,7 +91,7 @@ function truncateOutput(output) {
  * - codex: exec <message> --sandbox <permission>
  * - gemini: -p <message>
  * - vibe-local: [-p <message> -y] or [--model <model> -p <message> -y]
- * - opencode: [run <message>] or [run -m ollama/<model> <message>]
+ * - opencode: [run <message>] or [run -m <provider/model> <message>]
  * - antigravity: -p <message> --dangerously-skip-permissions
  * - others: -p <message> (fallback)
  *
@@ -113,9 +113,29 @@ function buildCliArgs(message, cliToolId, permission, options) {
             }
             return ['-p', message, '-y'];
         case 'opencode':
-            // [D2-007] When model is not specified, OpenCode uses opencode.json default model
+            // [D2-007] When model is not specified, OpenCode uses opencode.json default model.
+            //
+            // Issue #1914: the model is passed through **verbatim**. It used to be
+            // written as `ollama/${model}`, which had two problems and one excuse:
+            //
+            //  - `opencode run --help` documents `-m, --model` as taking a value "in
+            //    the format of provider/model" (measured on 1.18.21), so the prefix
+            //    made every non-Ollama provider unreachable and mangled any value that
+            //    already named one into `ollama/anthropic/…`.
+            //  - The prefix was a silent transform: nothing downstream could tell the
+            //    difference between "the user asked for Ollama" and "the code assumed
+            //    it".
+            //
+            // The excuse is that it never ran. `resolveModelOption()` answered
+            // `undefined` for opencode, and the only other caller
+            // (`daily-summary-generator`) is gated by `SUMMARY_ALLOWED_TOOLS`, which
+            // does not list opencode either — so there is no stored CMATE.md value
+            // that the removed prefix was keeping correct. The branch is kept rather
+            // than deleted because this Issue makes it reachable; deleting it would
+            // mean `opencode --model x` in CMATE.md parses, validates, and is then
+            // silently ignored, which is the same class of bug one layer down.
             if (options?.model) {
-                return ['run', '-m', `ollama/${options.model}`, message];
+                return ['run', '-m', options.model, message];
             }
             return ['run', message];
         case 'antigravity':

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

@@ -538,7 +538,7 @@ async function startClaudeSession(options) {
     // Check if Claude is installed
     const claudeAvailable = await isClaudeInstalled();
     if (!claudeAvailable) {
-        throw new Error('Claude CLI is not installed or not in PATH');
+        throw new session_start_error_1.SessionStartUnavailableError('Claude Code', 'Claude CLI is not installed or not in PATH');
     }
     const sessionName = getSessionName(worktreeId, instanceId);
     // Check if session already exists
@@ -658,6 +658,16 @@ async function startClaudeSession(options) {
             // dialog so a dialog still on screen is answered first.
             const errorPattern = findSessionErrorPattern(cleanOutput);
             if (errorPattern !== null) {
+                // Issue #2000 raised the push notification on this line. Issue #2009
+                // moved it up to `BaseCLITool.startSession`, which is the one method
+                // every tool inherits: six of the seven had no such line at all, and a
+                // seventh copy is how "only claude rings" happened in the first place.
+                // Nothing about what the reader receives changed — the error carries the
+                // tool name and the detected pattern, which is everything the
+                // notification was ever built from — and the sibling
+                // `SessionStartTimeoutError` below still deliberately does NOT notify
+                // (#1637: the session and its process are alive and the documented
+                // advice is to retry in a few seconds).
                 throw new session_start_error_1.SessionStartFailedError('Claude Code', sessionName, errorPattern);
             }
         }

package/dist/server/src/lib/session/composer-clear.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * Clear the CLI composer, and prove it (Issue #1879).
+ *
+ * The UI's [Clear] button promises one thing — "the input box is now empty" — so
+ * this is a verified operation, not a fire-and-forget key send. #1878 §5-1
+ * measured the two ways a single `C-u` silently fails:
+ *
+ *  1. **Cursor at column 0.** `C-u` kills the text *before* the cursor, so a
+ *     composer whose owner pressed Home before walking away survives it intact.
+ *     {@link clearComposerLine} fixes that by sending `C-e` first.
+ *  2. **Multi-row composer.** `C-u` clears the current row only. A two-row
+ *     residual needed three `C-e`+`C-u` passes before the box was actually
+ *     empty (`2N-1` for N rows).
+ *
+ * So the loop here is: read the frame → decide whether real text is still there
+ * → send one pass → read again. It stops the moment
+ * {@link extractComposerText} stops reporting `content`, which is also what
+ * makes it correct in the presence of a CLI's dim placeholder text: `C-u` cannot
+ * remove a suggestion that was never in the buffer, and a loop that compared
+ * ANSI-stripped strings instead would spin until its cap on every idle session
+ * with a hint on screen — claude's rotating suggestion, or codex's
+ * `Ask Codex to do anything` (Issue #1890).
+ *
+ * The capture is taken with {@link capturePane} directly rather than through
+ * `captureSessionOutput`, because that path is served by a 5-second TTL cache
+ * (`tmux-capture-cache`): read-back verification against a cached frame would be
+ * reading the composer as it looked before the key was sent. The cache is
+ * invalidated on the way out so the next poll/push does not serve the pre-clear
+ * frame back to the browser.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COMPOSER_CLEAR_REDRAW_DELAY_MS = exports.MAX_COMPOSER_CLEAR_PASSES = void 0;
+exports.clearComposer = clearComposer;
+const tmux_1 = require("../../lib/tmux/tmux");
+const tmux_capture_cache_1 = require("../../lib/tmux/tmux-capture-cache");
+const composer_text_1 = require("../../lib/detection/composer-text");
+const logger_1 = require("../../lib/logger");
+const logger = (0, logger_1.createLogger)('composer-clear');
+/**
+ * Upper bound on `C-e`+`C-u` passes.
+ *
+ * #1878 measured `2N-1` passes for an N-row composer, so this covers a composer
+ * of ~6 rows. The cap exists because the loop's exit condition depends on the
+ * TUI redrawing: a CLI that ignores the keys entirely must fail fast and report
+ * `cleared: false` rather than hold the request open.
+ */
+exports.MAX_COMPOSER_CLEAR_PASSES = 12;
+/** Rows of pane to capture for read-back. The composer is pinned to the bottom. */
+const CLEAR_READBACK_CAPTURE_LINES = 200;
+/** Grace given to the TUI to repaint after a pass, before reading the frame back. */
+exports.COMPOSER_CLEAR_REDRAW_DELAY_MS = 120;
+const defaultDelay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+/**
+ * Empty the composer of a running session and verify the result.
+ *
+ * @param sessionName - tmux session to act on (must already exist; the caller checks)
+ * @param cliToolId - CLI whose composer layout to read. `claude` and `codex` can
+ *   be verified today (see {@link extractComposerText}); for anything else the
+ *   extractor reports `unsupported_tool`, no pass is sent, and `cleared` is
+ *   false — a truthful "this endpoint cannot do that yet" rather than blind keys
+ *   into an input line nobody has measured.
+ */
+async function clearComposer(sessionName, cliToolId, options = {}) {
+    const capture = options.capture ?? ((name) => (0, tmux_1.capturePane)(name, CLEAR_READBACK_CAPTURE_LINES));
+    const sendClear = options.sendClear ?? tmux_1.clearComposerLine;
+    const delay = options.delay ?? defaultDelay;
+    const maxPasses = options.maxPasses ?? exports.MAX_COMPOSER_CLEAR_PASSES;
+    let passes = 0;
+    let result = (0, composer_text_1.extractComposerText)(await capture(sessionName), cliToolId);
+    // Snapshot before the first pass: every later read shows less of it (a pass
+    // eats one row), so this is the only moment the full text exists.
+    const discardedText = result.state === 'content' ? result.text : '';
+    while (result.state === 'content' && passes < maxPasses) {
+        await sendClear(sessionName);
+        passes++;
+        await delay(exports.COMPOSER_CLEAR_REDRAW_DELAY_MS);
+        result = (0, composer_text_1.extractComposerText)(await capture(sessionName), cliToolId);
+    }
+    // Whatever happened above, the cached frame is now stale: the poller and the
+    // WebSocket push both read through `captureSessionOutput`, and serving the
+    // pre-clear frame would leave the bar on screen after the text is gone.
+    if (passes > 0)
+        (0, tmux_capture_cache_1.invalidateCache)(sessionName);
+    // Positive confirmation only. `unsupported_tool` (nothing here can read that
+    // CLI's box) and `no_composer` (the box is not on screen, so the buffer behind
+    // whatever overlay is up was never inspected) are both "not verified", and
+    // reporting them as success would let the UI claim it emptied something it
+    // never looked at. Callers get `state` to tell the two apart.
+    const cleared = result.state === 'empty' || result.state === 'ghost';
+    if (!cleared) {
+        logger.warn('composer-clear:not-cleared', { sessionName, cliToolId, passes, state: result.state });
+    }
+    return { cleared, passes, state: result.state, remainingText: result.text, discardedText };
+}

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

@@ -12,10 +12,15 @@ exports.mergeStructuredStatus = mergeStructuredStatus;
 exports.buildCurrentOutput = buildCurrentOutput;
 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 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 registry_1 = require("../../lib/hooks/sources/registry");
+const permission_decision_state_1 = require("../../lib/hooks/permission-decision-state");
+const tool_input_normalization_state_1 = require("../../lib/hooks/tool-input-normalization-state");
 const cli_session_1 = require("../../lib/session/cli-session");
 const status_detector_1 = require("../../lib/detection/status-detector");
 const auto_yes_manager_1 = require("../../lib/polling/auto-yes-manager");
@@ -25,6 +30,8 @@ const status_capture_config_1 = require("../../config/status-capture-config");
 const tmux_capture_cache_1 = require("../../lib/tmux/tmux-capture-cache");
 const agent_event_state_1 = require("../../lib/session/agent-event-state");
 const prompt_waiting_composition_1 = require("../../lib/session/prompt-waiting-composition");
+const provisional_turn_1 = require("../../lib/session/provisional-turn");
+const status_evidence_1 = require("../../lib/session/status-evidence");
 const ask_user_question_prompt_1 = require("../../lib/session/ask-user-question-prompt");
 const structured_prompt_1 = require("../../lib/session/structured-prompt");
 const logger = (0, logger_1.createLogger)('current-output-builder');
@@ -208,28 +215,34 @@ function summarizeAskUserQuestion(episode) {
  * those, passed in explicitly; the raw `structured.status === 'waiting'` still
  * decides nothing on its own.
  *
- * ## The one flag this touches beyond `sessionStatus`
+ * ## `isUnclassifiedActive` is not this function's to move (Issue #2011)
  *
- * `isUnclassifiedActive` is cleared only for the `Stop`-arrived-but-the-pane-
- * still-looks-busy case (structured `ready` over scraper `running`). That case
- * is the entire point of the Issue for `commandmate wait`, whose completion
- * check is `sessionStatus === 'ready' && isUnclassifiedActive !== true` — leave
- * the flag up and the structured `ready` buys nothing.
- *
- * Everywhere else the flag is left exactly as the scraper set it, which is not
- * timidity but two specific behaviours that must survive:
+ * The flag is carried through from the scraper on every path. It answers "could
+ * the detection layer read this frame?", and no amount of knowledge about the
+ * TURN changes the answer for the FRAME:
  *
  *  - a static overlay left on screen after a turn (`/help`, #1497) reads as
- *    `ready`/`no_recent_output` while the structured layer also says `ready` —
- *    the two agree, the structured layer adds nothing, and clearing the flag
- *    would take away the navigation hatch the user needs to escape;
+ *    `running`/`no_recent_output` while the structured layer says `ready` — the
+ *    structured layer adds nothing about the screen, and clearing the flag would
+ *    take away the navigation hatch the user needs to escape;
  *  - a frame nobody can classify while the structured layer says `running` is
  *    still a frame nobody can classify. `wait`'s unclassified dwell (exit 10)
  *    is the last hatch for a screen that produces no events at all, and #1708
  *    exists because it was missing. A structured `running` does not prove a
  *    human is not needed — see the AskUserQuestion case above.
+ *
+ * `#1723`'s reported case — `Stop` arrives while the spinner is still painted —
+ * needs no help from here: that frame reads `running`/`thinking_indicator`, which
+ * is classified, so the flag was already down and `wait` completes on the
+ * structured `ready` alone.
+ *
+ * What this function DOES move is `evidence`, and only upwards: see
+ * {@link hookClosedTurn}.
+ *
+ * @param turn - The published turn record for this instance, or null. Read only
+ *   for {@link hookClosedTurn}; `structured` remains the status authority.
  */
-function mergeStructuredStatus(scraper, structured, promptWaiting = null) {
+function mergeStructuredStatus(scraper, structured, promptWaiting = null, turn = null) {
     if (scraper.status === 'waiting') {
         return { ...scraper, structuredApplied: false };
     }
@@ -244,6 +257,9 @@ function mergeStructuredStatus(scraper, structured, promptWaiting = null) {
             status: 'waiting',
             reason: (0, prompt_waiting_composition_1.structuredWaitingReason)(promptWaiting),
             thinking: false,
+            // Untouched: what the scraper could read about this frame does not change
+            // because the agent told us a dialog is open (Issue #1924).
+            evidence: scraper.evidence,
             isUnclassifiedActive: scraper.isUnclassifiedActive,
             structuredApplied: true,
         };
@@ -252,39 +268,149 @@ function mergeStructuredStatus(scraper, structured, promptWaiting = null) {
         return { ...scraper, structuredApplied: false };
     }
     const thinking = structured.status === 'running';
+    // Issue #2011 (対応 2): the agent's own turn close IS positive evidence.
+    //
+    // #1927 (DR2-003) guarded this override with `scraper.evidence === 'positive'`
+    // to stop a structured `ready` clearing `isUnclassifiedActive` on a frame
+    // nobody could read. It over-corrected twice over. First, the conjunct made
+    // the whole expression a no-op: `evidence = cond ? 'positive' : scraper.evidence`
+    // where `cond` requires `scraper.evidence === 'positive'` returns
+    // `scraper.evidence` on both arms, so the branch could not change a value in
+    // any direction. Second, the fix it was reaching for belonged one field over —
+    // the hatch is held open by {@link ScraperVerdict.isUnclassifiedActive}, which
+    // is carried through below rather than re-derived, so the evidence no longer
+    // has to be understated to protect it.
+    //
+    // What that leaves is a payload that stopped contradicting itself. A pane
+    // whose `reason` reads `hook_stop` while `statusEvidence` reads `'none'` is
+    // denying, in one field, the strongest positive signal this server can get: a
+    // `Stop` from the agent, for a turn this server watched open. `closedAt >
+    // openedAt` is what narrows it to that case — a `Stop` that arrived with no
+    // turn open publishes `openedAt: null` (see `recordAgentEvent`), and a close
+    // the SCREEN inferred carries one of the other {@link TurnCloseReason} values.
+    // Freshness needs no bound of its own: `getStructuredSessionState` answered
+    // null above once the display event passed STRUCTURED_STATE_MAX_AGE_MS.
+    //
+    // `scraper.status === 'running'` is deliberately NOT required. The session this
+    // Issue was reported from sat at `ready`/`input_prompt` with `closedBy: 'stop'`
+    // — the agent had said it was done and the frame agreed — and the old conjunct
+    // is what kept publishing `'none'` for it.
+    const evidence = structured.status === 'ready' && hookClosedTurn(turn) ? 'positive' : scraper.evidence;
     return {
         status: structured.status,
         reason: structured.reason,
         thinking,
-        isUnclassifiedActive: structured.status === 'ready' && scraper.status === 'running'
-            ? false
-            : scraper.isUnclassifiedActive,
+        evidence,
+        // Issue #2011: what the structured layer knows about the TURN says nothing
+        // about whether this FRAME could be read. #1708's dwell and the nav hatch
+        // are the last way out of a pane nothing can drive, and a `Stop` does not
+        // make an unreadable pane readable — see the `/help` overlay fixture in
+        // `tests/unit/lib/detection/fixtures/claude-live-2011/`.
+        isUnclassifiedActive: scraper.isUnclassifiedActive,
         structuredApplied: true,
     };
 }
+/**
+ * Whether the agent's own `Stop` closed a turn this server watched open
+ * (Issue #2011, 対応 2).
+ *
+ * Both halves are required. `closedBy: 'stop'` rules out the five close reasons
+ * that are the server's inference rather than the agent's word (`stale`,
+ * `generation`, `session_end`, `scraper_evidence`, `resync_idle`), and
+ * `closedAt > openedAt` rules out a `Stop` whose turn was never observed
+ * opening — `recordAgentEvent` publishes `openedAt: null` for that, and a close
+ * with nothing behind it is not a completion anybody watched.
+ */
+function hookClosedTurn(turn) {
+    if (turn === null)
+        return false;
+    const { closedBy, closedAt, openedAt } = turn;
+    return closedBy === 'stop' && closedAt !== null && openedAt !== null && closedAt > openedAt;
+}
 /**
  * Build the current-output payload for a worktree session.
  *
  * @param db - Database instance
  * @param worktreeId - Worktree ID (assumed already validated by the caller)
- * @param cliToolId - CLI tool ID
+ * @param cliToolId - CLI tool ID, ALREADY resolved by the caller
  * @param instanceId - Optional agent instance ID (defaults to the primary instance)
+ * @param resolution - How the caller resolved that pair, when it resolved one
+ *   (Issue #1884). Appended to the payload; nothing here reads it.
  */
-async function buildCurrentOutput(db, worktreeId, cliToolId, instanceId) {
+async function buildCurrentOutput(db, worktreeId, cliToolId, instanceId, resolution) {
+    const payload = await buildPayload(db, worktreeId, cliToolId, instanceId);
+    if (!resolution)
+        return payload;
+    return {
+        ...payload,
+        resolvedBy: resolution.resolvedBy,
+        // Explicit null rather than an absent key: `capture --json | jq '.conflict'`
+        // must answer "no contradiction" rather than nothing at all, exactly as
+        // `model` does.
+        conflict: resolution.conflict ?? null,
+    };
+}
+/**
+ * The payload itself, with no knowledge of how its (tool, instance) pair was
+ * chosen. Split from {@link buildCurrentOutput} so the resolution fields are
+ * appended in one place instead of at both of the two return sites below.
+ */
+async function buildPayload(db, worktreeId, cliToolId, instanceId) {
     const resolvedInstanceId = instanceId ?? cliToolId;
     const manager = manager_1.CLIToolManager.getInstance();
     const cliTool = manager.getTool(cliToolId);
     const stopEventAt = (0, agent_event_state_1.getLastStopEventAt)(worktreeId, cliToolId, instanceId);
     const lastEvent = (0, agent_event_state_1.getLastAgentEvent)(worktreeId, cliToolId, instanceId);
+    // Issue #1924: the registry answers for every tool — a real implementation
+    // when there is one, the compatibility source otherwise — so this needs no
+    // null branch and never names a tool.
+    const eventSource = (0, registry_1.getAgentEventSource)(cliToolId);
+    const now = Date.now();
+    const pendingDecisions = (0, agent_event_state_1.getPendingDecisions)(worktreeId, cliToolId, instanceId, now);
     const structuredEvents = {
         lastEventType: lastEvent?.event ?? null,
         lastEventAt: lastEvent?.at ?? null,
         lastEventDetail: lastEvent?.detail ?? null,
+        // Issue #1926 published these; Issue #1930 made them a real record. Read
+        // before the `isRunning` branch so both return paths carry the turn fields.
+        ...(0, agent_event_state_1.getPublishedAgentTurn)(worktreeId, cliToolId, instanceId, now),
+        // Issue #1930. `deliveryExpired` is computed HERE and only here, because
+        // this is the layer that holds both halves: the record's age, and the
+        // source's declared `decisionTimeoutSeconds`. `agent-event-state` cannot
+        // reach the registry — its module graph pulls in `better-sqlite3` — which
+        // is why every capability arrives there as a value a caller hands over.
+        pendingDecisions: pendingDecisions.map((decision) => ({
+            id: decision.decisionId,
+            at: decision.at,
+            source: decision.source,
+            toolName: decision.toolName,
+            confirmedAt: decision.confirmedAt,
+            scraperCorroborated: decision.scraperCorroborated,
+            deliveryExpired: (0, provisional_turn_1.isDeliveryExpired)(decision, eventSource.capabilities.decisionTimeoutSeconds, now),
+        })),
+        dedupDropped: (0, agent_event_state_1.getAgentEventDropCounts)(worktreeId, cliToolId, instanceId),
+        dialogPendingMaxMs: { ...provisional_turn_1.DIALOG_PENDING_MAX_MS },
         promptWaitingSince: null,
         promptWaitingSource: null,
+        // Issue #1902. Read here, before the `isRunning` branch, so both return
+        // paths carry it.
+        toolInputNormalization: (0, tool_input_normalization_state_1.getLastToolInputNormalization)(worktreeId, cliToolId, instanceId),
+        // Issue #1898, the same shape and for the same reason: an automatic verdict
+        // this server delivered on the agent's behalf is invisible to the operator
+        // otherwise. Exposure only — the dialog state is `promptWaitingSince` /
+        // `isPromptWaiting`, and nothing reads this back to decide anything.
+        permissionDecision: (0, permission_decision_state_1.getLastPermissionDecision)(worktreeId, cliToolId, instanceId),
+        source: {
+            cliToolId: eventSource.cliToolId,
+            capabilities: eventSource.capabilities,
+        },
     };
     const running = await cliTool.isRunning(worktreeId, instanceId);
     if (!running) {
+        // Issue #1926: the latch describes a process, and this one is gone. Dropped
+        // rather than aged out so the next session on this key starts with no
+        // history instead of inheriting the last one's verdict.
+        (0, status_evidence_1.forgetLastKnownStatus)((0, auto_yes_manager_1.buildCompositeKey)(worktreeId, cliToolId, instanceId));
         return {
             isRunning: false,
             content: '',
@@ -292,6 +418,13 @@ async function buildCurrentOutput(db, worktreeId, cliToolId, instanceId) {
             cliToolId,
             sessionStatus: 'idle',
             sessionStatusReason: 'session_not_running',
+            // Issue #1926: `'positive'` is not a formality here. tmux was asked and
+            // answered — the absence of the session is a fact this layer observed,
+            // not a pattern that failed to match, which is the whole distinction §4 D1
+            // is drawing.
+            statusEvidence: 'positive',
+            lastKnownStatus: null,
+            lastKnownStatusAt: null,
             lastStopEventAt: stopEventAt,
             structuredEvents,
             // Issue #1785: null on a dead session, not the last model it ran. The
@@ -314,6 +447,11 @@ async function buildCurrentOutput(db, worktreeId, cliToolId, instanceId) {
             // is a claim about what is on screen right now, and a dead session has no
             // screen.
             upstreamFault: null,
+            // Issue #1879: same reasoning as `upstreamFault` — there is no input box
+            // on a session that is not running, so there is nothing to report and
+            // nothing the UI could act on.
+            composerText: null,
+            composerState: 'no_composer',
         };
     }
     const sessionState = (0, db_1.getSessionState)(db, worktreeId, resolvedInstanceId);
@@ -333,30 +471,75 @@ async function buildCurrentOutput(db, worktreeId, cliToolId, instanceId) {
     // capture layer will ever fetch — captureSessionOutput() reads at most
     // CACHE_MAX_CAPTURE_LINES regardless of the request.
     const captureWindowSaturated = (0, tmux_capture_cache_1.isCaptureWindowSaturated)(totalLines, Math.min(status_capture_config_1.STATUS_CAPTURE_LINES, tmux_capture_cache_1.CACHE_MAX_CAPTURE_LINES));
-    const newLines = captureWindowSaturated ? lines : lines.slice(Math.max(0, lastCapturedLine));
+    // Issue #1910: saturation of the capture WINDOW is only one of the two ways
+    // the cursor dies, and it is the one that never fires for the alternate-screen
+    // tools — their pane is 1000 rows (claude / copilot) or 200 (opencode), so a
+    // 10000-line window is never reached and the branch above stayed false
+    // forever. Meanwhile the poller stores `lastCapturedLine` for them too
+    // (`updateSessionState` is called unconditionally; only the DEDUP comparison
+    // is gated on the tool, response-checker.ts), so after one turn the stored
+    // 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 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);
     const lastServerResponseTimestamp = (0, auto_yes_manager_1.getLastServerResponseTimestamp)(compositeKey);
     const lastOutputTimestamp = lastServerResponseTimestamp ? new Date(lastServerResponseTimestamp) : undefined;
     const statusResult = (0, status_detector_1.detectSessionStatus)(output, cliToolId, lastOutputTimestamp);
-    const thinking = statusResult.status === 'running' && statusResult.reason === status_detector_1.STATUS_REASON.THINKING_INDICATOR;
+    // Issue #1912: every `running` reason that means "the agent is producing
+    // output", not just `thinking_indicator`. opencode answers
+    // `opencode_processing_indicator` for its `esc interrupt` footer, which is
+    // the only signal it gives between the submitted prompt and the first
+    // transcript row — on a scraper-only session that stretch showed no
+    // thinking indicator at all.
+    const thinking = (0, status_detector_1.isGeneratingStatus)(statusResult);
     const scraperPromptWaiting = statusResult.hasActivePrompt;
     const isSelectionListActive = statusResult.status === 'waiting' && status_detector_1.SELECTION_LIST_REASONS.has(statusResult.reason);
     const isPagerActive = statusResult.reason === status_detector_1.STATUS_REASON.CODEX_PAGER;
     // Issue #1497: the detection-independent nav hatch (#1017/#1494) is gated on
     // isUnclassifiedActive. A static, unrecognized TUI overlay (e.g. Claude `/help`)
-    // whose frame stops changing degrades from `running`/`default` to `ready`/
+    // whose frame stops changing degrades from `running`/`default` to
     // `no_recent_output` once the Auto-Yes poller has stamped lastOutputTimestamp
     // (its sole writer, auto-yes-poller.ts). That is still an interactive-but-
     // unclassified frame — a real idle prompt (`❯`) is classified earlier as
     // `input_prompt`, never as `no_recent_output` — so treat the timed-out fallback
     // as unclassified too and keep the hatch open instead of stranding the user.
-    const isUnclassifiedActive = (statusResult.status === 'running' && statusResult.reason === status_detector_1.STATUS_REASON.DEFAULT) ||
-        (statusResult.status === 'ready' && statusResult.reason === status_detector_1.STATUS_REASON.NO_RECENT_OUTPUT);
+    // Issue #1924, §4 D1 decision 2: stated as evidence. Issue #1927 moved that
+    // PRODUCER into the detector, because only the detector knows which rule
+    // answered — `input_prompt` is positive for a tool whose idle rule vouched for
+    // the frame and `'none'` for one whose rule declined, with the same status and
+    // the same reason on the wire.
+    const evidence = statusResult.evidence;
+    // Issue #2011: the flag is NOT that fact, and deriving it from `evidence` is
+    // the regression this Issue fixes. `'none'` is "I could not prove this pane is
+    // idle" — an ordinary Claude composer with no completion marker above it
+    // qualifies, and 7 of 8 live idle panes did on 2026-08-24. The flag's three
+    // consumers all ask the older, narrower question instead: `TerminalEscapeHatch`
+    // opens on a frame a human has to drive by hand, `wait` suppresses its
+    // completion check and eventually exits 10 on one, and `unclassified_frames`
+    // records it as a detection failure worth capturing as a fixture. That is
+    // `isUnclassifiedFrame` — the reason vocabulary, not the strength of the
+    // evidence behind a readable verdict.
+    const isUnclassifiedActive = (0, status_evidence_1.isUnclassifiedFrame)(statusResult.status, statusResult.reason);
     // Issue #1723: the two-layer merge. Everything above this line is the string
     // analysis, unchanged and still the only source on a machine where no hook
     // ever fires — `getStructuredSessionState` answers null there, and
     // `mergeStructuredStatus` then returns the scraper's verdict untouched.
+    // Issue #1930: the screen's own half of "is this turn over". Fed BEFORE the
+    // structured state is read so a poll that closes the turn is the poll that
+    // reports it, and fed with the SCRAPER's verdict rather than the merged one —
+    // reading the merge back would be circular, since the merge is where this
+    // layer's `running` overrides the frame.
+    //
+    // What this buys is a bound on a lost `Stop` far shorter than the 30-minute
+    // staleness rule: three consecutive frames that positively read as a finished
+    // composer retire the structured `running`, and the pane goes back to being
+    // the scraper's to describe. What it deliberately does NOT do is complete a
+    // `commandmate wait` — see SCRAPER_COMPLETION_POLLS, and #1839's measurement
+    // of a 529 storm returning Claude to exactly this frame having run nothing.
+    (0, agent_event_state_1.observeScraperCompletionEvidence)(worktreeId, cliToolId, instanceId, statusResult.status === 'ready' && evidence === 'positive');
     const structured = (0, agent_event_state_1.getStructuredSessionState)(worktreeId, cliToolId, instanceId);
     // Issue #1725: the open-dialog half of the same merge, resolved before the
     // status merge because it decides one of its inputs. The rule itself — the
@@ -378,7 +561,19 @@ async function buildCurrentOutput(db, worktreeId, cliToolId, instanceId) {
         structuredEvents.promptWaitingSince = promptWaiting.at;
         structuredEvents.promptWaitingSource = promptWaiting.source;
     }
-    const merged = mergeStructuredStatus({ status: statusResult.status, reason: statusResult.reason, thinking, isUnclassifiedActive }, structured, promptWaiting);
+    const merged = mergeStructuredStatus({
+        status: statusResult.status,
+        reason: statusResult.reason,
+        thinking,
+        evidence,
+        isUnclassifiedActive,
+    }, structured, promptWaiting, 
+    // Issue #2011: the same record `structuredEvents` publishes, read once. The
+    // merge needs `closedBy` / `closedAt` / `openedAt`, which
+    // `StructuredSessionState` folds away into `hook_stop` — and the folded form
+    // cannot tell a `Stop` that closed a watched turn from one that arrived with
+    // no turn open.
+    structuredEvents);
     // The OR rule, computed once for the whole server (Issue #1737): this is the
     // same `resolvePromptWaiting` call the `send` guard makes, so the payload and
     // the guard cannot disagree about whether a prompt is open. What they are
@@ -399,9 +594,27 @@ async function buildCurrentOutput(db, worktreeId, cliToolId, instanceId) {
     // The degraded form, for a dialog only the structured layer can see. Enriched
     // with the question text when one is in flight — that turns "a dialog is open
     // and nobody could read it" into "a dialog is open and here is what it asks".
+    //
+    // Issue #1898 adds the replies the dialog accepts, for the sources that can be
+    // answered without touching the pane. The gate is `eventIdentity`: a source
+    // that publishes a per-decision id is a source whose approval can be answered
+    // by that id, which is what makes an option NUMBER here mean something other
+    // than a line on a screen nobody parsed. `source === 'notification'` narrows
+    // it to a dialog the agent actually reported — a `permission-request` record
+    // is a prediction, and a question is answered with a choice rather than with
+    // one of these three verdicts.
+    const decisionOptions = promptWaiting !== null &&
+        promptWaiting.source === 'notification' &&
+        eventSource.capabilities.eventIdentity === 'permission-id'
+        ? structured_prompt_1.STRUCTURED_DECISION_OPTIONS
+        : null;
     const structuredFacts = promptWaiting === null
         ? null
-        : { ...promptWaiting, askUserQuestion: summarizeAskUserQuestion(askUserQuestion) };
+        : {
+            ...promptWaiting,
+            askUserQuestion: summarizeAskUserQuestion(askUserQuestion),
+            decisionOptions,
+        };
     const promptData = scraperPromptWaiting
         ? correctedPromptData ??
             scraperPromptData ??
@@ -468,6 +681,10 @@ async function buildCurrentOutput(db, worktreeId, cliToolId, instanceId) {
             facts: structuredFacts,
         });
     }
+    // Issue #1879: structural, and computed here next to the other frame readers
+    // rather than inside a status branch — the bar it feeds must appear on the
+    // strength of what is in the box, never on the strength of a status verdict.
+    const composer = (0, composer_text_1.extractComposerText)(output, cliToolId);
     const realtimeSnippet = lines.slice(-100).join('\n');
     // Issue #1839: judged on exactly what is published as `realtimeSnippet`, not
     // on `output`. The wider capture keeps a banner from an hour ago in scope, and
@@ -486,6 +703,18 @@ async function buildCurrentOutput(db, worktreeId, cliToolId, instanceId) {
     // in antigravity's rule that the effort comes from the model id, which a bare
     // read of the scraped half would drop.
     const { model, effort } = (0, agent_event_state_1.getResolvedAgentModelInfo)(worktreeId, cliToolId, instanceId);
+    // Issue #1926, §7: fed the MERGED verdict, for the reason the unclassified
+    // tracker above is — this is the verdict that gets published, so latching the
+    // scraper's raw reading would make `lastKnownStatus` disagree with the
+    // `sessionStatus` it sat next to one poll earlier. Observed before it is read
+    // so a positive poll reports itself, which is what keeps the field from
+    // looking stale on a healthy session.
+    (0, status_evidence_1.observeStatusEvidence)(compositeKey, {
+        status: merged.status,
+        reason: merged.reason,
+        evidence: merged.evidence,
+    });
+    const lastKnown = (0, status_evidence_1.getLastKnownStatus)(compositeKey);
     return {
         isRunning: true,
         cliToolId,
@@ -514,6 +743,12 @@ async function buildCurrentOutput(db, worktreeId, cliToolId, instanceId) {
         isSelectionListActive,
         isPagerActive,
         isUnclassifiedActive: merged.isUnclassifiedActive,
+        // Issue #1926: the same fact `isUnclassifiedActive` carries, named the way
+        // §4 D1 names it. Published from the merged verdict so the two cannot
+        // disagree on the wire.
+        statusEvidence: merged.evidence,
+        lastKnownStatus: lastKnown?.status ?? null,
+        lastKnownStatusAt: lastKnown?.at ?? null,
         lastServerResponseTimestamp,
         serverPollerActive: (0, auto_yes_manager_1.isPollerActive)(compositeKey),
         lastStopEventAt: stopEventAt,
@@ -535,5 +770,12 @@ async function buildCurrentOutput(db, worktreeId, cliToolId, instanceId) {
                 at: Date.now(),
             }
             : null,
+        // Issue #1879: read from `output` — the RAW capture, still carrying the SGR
+        // attributes `capture-pane -e` fetched. Everything else in this function
+        // works on stripped text; this one deliberately does not, because dim is the
+        // only thing that separates Claude's ghost suggestion from text a human
+        // typed. Do not "tidy" this to read a stripped variable.
+        composerText: composer.state === 'content' ? composer.text : null,
+        composerState: composer.state,
     };
 }