commandmate 0.23.0 → 0.24.0

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

@@ -0,0 +1,384 @@
+"use strict";
+/**
+ * Model / reasoning-effort extraction from the terminal frame (Issue #1784).
+ *
+ * Phase 1 (#1783) reads the model off the agents' own structured hook events.
+ * That channel has one hole and one gap:
+ *
+ *  - **No effort, anywhere.** Not one hook payload of any tool carries a
+ *    reasoning-effort field (verified across every fixture under
+ *    `tests/fixtures/hooks/`). The only place the number exists at all is on
+ *    screen, in the TUI's own chrome.
+ *  - **No model after a restart, for Claude.** Claude publishes its model on
+ *    `SessionStart` and on nothing else, so a server that restarts mid-session
+ *    never hears it again for that session. The banner is still in scrollback.
+ *
+ * This module is the screen-scraped half. It is deliberately a *separate* set of
+ * patterns from `cli-patterns.ts`: two of the patterns it would otherwise have
+ * been tempting to extend are load-bearing for behaviour that has nothing to do
+ * with display —
+ *
+ *  - `CODEX_STATUS_BAR_PATTERN` is the footer boundary the Codex running/idle
+ *    decision is windowed on (#1150). Widening it to capture groups risks the
+ *    dot.
+ *  - `CLAUDE_MODEL_OVERLAY_FOOTER_PATTERN` is the guard that stops Auto-Yes from
+ *    Enter-confirming the `/model` picker and rewriting the user's **global
+ *    default model** (#1495).
+ *
+ * So: read-only reuse of `CODEX_STATUS_BAR_PATTERN` to *locate* the footer (one
+ * definition of "which line is the status bar", shared with the detector), new
+ * patterns to read values out of it, and not one byte changed in either file.
+ *
+ * ## Where the values come from (all measured on real TUIs, 2026-08-15)
+ *
+ * | tool        | line                                                             |
+ * |-------------|------------------------------------------------------------------|
+ * | codex       | footer:  `gpt-5.6-sol xhigh · ~/share/work/…`                     |
+ * | claude      | banner:  `▝▜█████▛▘  Opus 5 (1M context) with xhigh effort · Claude Max` |
+ * | antigravity | footer:  `? for shortcuts …               Gemini 3.7 Flash · hig` |
+ * | antigravity | banner:  `    ▀▀▀▀▀▀▀▀      Gemini 3.7 Flash (High)`              |
+ *
+ * Everything is matched **after** `stripAnsi`. The real captures are shot
+ * through with SGR sequences *inside* the value — the Codex footer arrives as
+ * `\x1b[38;2;…mgpt-5.6-sol xhigh\x1b[2m\x1b[39m · …` — so a pattern applied to
+ * the raw bytes matches nothing at all. `tests/fixtures/model-info-captures.ts`
+ * keeps one ANSI-bearing capture precisely so a regression here fails a test
+ * rather than a user's screen.
+ *
+ * ## Not a new capture
+ *
+ * Nothing here issues a `capture-pane`. {@link extractModelInfo} is a pure
+ * function of text the status-detection poll already fetched
+ * (`worktree-status-helper.ts`), so the added load is zero.
+ *
+ * @see Issue #1784, Phase 2 of the model/effort visibility series
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ANTIGRAVITY_MODEL_ID_EFFORT_PATTERN = exports.ANTIGRAVITY_BANNER_MODEL_PATTERN = exports.ANTIGRAVITY_STATUS_BAR_HINT_PATTERN = exports.CLAUDE_STARTUP_BANNER_PATTERN = exports.CODEX_FOOTER_MODEL_PATTERN = exports.REASONING_EFFORT_LEVELS = void 0;
+exports.resolveEffortToken = resolveEffortToken;
+exports.extractModelInfo = extractModelInfo;
+exports.deriveEffortFromModelId = deriveEffortFromModelId;
+exports.mergeModelInfo = mergeModelInfo;
+const ansi_1 = require("./ansi");
+const cli_patterns_1 = require("./cli-patterns");
+/**
+ * The reasoning-effort vocabulary these tools actually print.
+ *
+ * `minimal` and `xhigh` are the ends Codex exposes; Claude prints `xhigh` too.
+ * Anything outside this list is treated as "not an effort token", which is what
+ * keeps a stray word at the end of a status bar from being published as one.
+ */
+exports.REASONING_EFFORT_LEVELS = ['minimal', 'low', 'medium', 'high', 'xhigh'];
+/**
+ * Longest string accepted as a model name.
+ *
+ * A bound, not a format check: the point is that a runaway match (a wrapped
+ * conversation line that happened to satisfy the shape) is rejected rather than
+ * pushed into the UI and the API. Real ids are far shorter — the longest
+ * observed is `Opus 5 (1M context)` at 19.
+ */
+const MAX_MODEL_NAME_LENGTH = 64;
+/** An unknown answer. Freshly built each time — callers may keep the object. */
+function unknown() {
+    return { model: null, effort: null };
+}
+/**
+ * Bare model *token* shape — Codex, whose footer prints the raw id.
+ *
+ * No spaces: the Codex footer's model is one token (`gpt-5.6-sol`, `o4-mini`).
+ */
+const MODEL_TOKEN_SHAPE = /^[A-Za-z0-9][A-Za-z0-9._:@/-]*$/;
+/**
+ * Model *label* shape — Claude and Antigravity, which print a display name.
+ *
+ * Spaces, dots and parentheses are in (`Opus 5 (1M context)`, `Gemini 3.7
+ * Flash`); anything else — box glyphs, `?`, `·`, `>` — is out, which is what
+ * rejects a status-bar hint that was mistaken for the model.
+ */
+const MODEL_LABEL_SHAPE = /^[A-Za-z0-9][A-Za-z0-9 .()[\]_:@/-]*$/;
+function isPlausibleModelToken(value) {
+    return value.length > 0 && value.length <= MAX_MODEL_NAME_LENGTH && MODEL_TOKEN_SHAPE.test(value);
+}
+function isPlausibleModelLabel(value) {
+    return value.length > 0 && value.length <= MAX_MODEL_NAME_LENGTH && MODEL_LABEL_SHAPE.test(value);
+}
+/**
+ * Resolve a word to a {@link ReasoningEffort}, or null.
+ *
+ * `allowTruncated` exists for exactly one measured defect: **agy 1.1.13 renders
+ * its right-aligned status bar one column short**, so `high` reaches the pane as
+ * `hig` at every width tested (200 and 120 both produce a 199-/119-column line
+ * whose last glyph is missing). Accepting a one-character-short prefix recovers
+ * it. The prefix must resolve to exactly one level, so nothing ambiguous is ever
+ * promoted — `hig`→`high`, `lo`→`low`, `mediu`→`medium`, `xhig`→`xhigh`, and a
+ * single letter resolves to nothing.
+ *
+ * Off for Codex and Claude: neither truncates, and loosening a matcher that does
+ * not need it only buys false positives.
+ */
+function resolveEffortToken(token, options = {}) {
+    const normalized = token.trim().toLowerCase();
+    if (normalized === '')
+        return null;
+    if (exports.REASONING_EFFORT_LEVELS.includes(normalized))
+        return normalized;
+    if (!options.allowTruncated || normalized.length < 2)
+        return null;
+    const candidates = exports.REASONING_EFFORT_LEVELS.filter((level) => level.length === normalized.length + 1 && level.startsWith(normalized));
+    return candidates.length === 1 ? candidates[0] : null;
+}
+// =============================================================================
+// Codex
+// =============================================================================
+/**
+ * Reads `<model>[ <effort>]` off the head of a Codex status bar (Issue #1784).
+ *
+ * Applied to the segment *before* the first "·", which is what makes one pattern
+ * cover all three footer formats the CLI has shipped:
+ *
+ *   v0.147 / v0.141: `gpt-5.6-sol xhigh · ~/share/work/…`      → head `gpt-5.6-sol xhigh `
+ *   legacy w/ quota: `gpt-5.4 high · 21% left · ~/…`           → head `gpt-5.4 high `
+ *   legacy o4-mini:  `  o4-mini            50% left · /path`   → head `  o4-mini            50% left `
+ *
+ * The last one is why the effort group is optional *and* why it is anchored to a
+ * keyword rather than "the second token": that format's second token is `50%`,
+ * and a positional read would publish "50%" as the reasoning effort.
+ *
+ * No /g flag (stateless `exec`). No nested quantifiers — `[^\s·]+` and the
+ * optional `\s+<keyword>` are adjacent, never nested (ReDoS-safe, same rule
+ * `cli-patterns.ts` documents).
+ */
+exports.CODEX_FOOTER_MODEL_PATTERN = /^\s*([^\s·]+)(?:\s+(minimal|low|medium|high|xhigh)\b)?/i;
+function readCodexFooter(line) {
+    // Same "is this the status bar" question the detector asks, answered by the
+    // same pattern (#1150). Imported read-only: this module must never be the
+    // reason that boundary moves.
+    if (!cli_patterns_1.CODEX_STATUS_BAR_PATTERN.test(line))
+        return null;
+    const separator = line.indexOf('·');
+    if (separator < 0)
+        return null;
+    const match = exports.CODEX_FOOTER_MODEL_PATTERN.exec(line.slice(0, separator));
+    if (!match)
+        return null;
+    const model = match[1];
+    if (!isPlausibleModelToken(model))
+        return null;
+    const effort = match[2] ? resolveEffortToken(match[2]) : null;
+    // `CODEX_STATUS_BAR_PATTERN` is a *boundary* test — "a token, a middle dot, a
+    // trailing path" — and the detector can afford that because it only ever asks
+    // it inside a window it already knows the footer is in. Reading values needs
+    // one more bit of evidence, because a sentence Codex printed about a file
+    // ("Updated · /src/foo.ts") satisfies the boundary shape, and a value read
+    // here LATCHES for the rest of the session. Every Codex model id carries a
+    // version number, so a digit in the token or a recognised effort keyword
+    // beside it is what separates chrome from prose.
+    if (effort === null && !/\d/.test(model))
+        return null;
+    return { model, effort };
+}
+// =============================================================================
+// Claude
+// =============================================================================
+/**
+ * Reads `<model> with <effort> effort` off the Claude startup banner (#1784).
+ *
+ * Measured on claude 2.1.232:
+ *   `▝▜█████▛▘  Opus 5 (1M context) with xhigh effort · Claude Max`
+ *
+ * Three deliberate choices:
+ *
+ *  - **The block/box glyph is required.** `U+2500–U+259F` covers both the ASCII
+ *    art of the plain banner (`▝▜█████▛▘`) and the frame of the boxed welcome
+ *    variant (`│   Opus 4.8 (1M context) with xhigh effort · Claude Max │`,
+ *    `tests/fixtures/claude-model-overlay.ts`). Without it, a *reply* containing
+ *    the words "…with high effort…" would be scraped as a model — Claude's own
+ *    prose shares the pane with its chrome.
+ *  - **The plan suffix is not matched.** `· Claude Max` is one plan of several
+ *    and is not part of the model; the match ends at `effort`.
+ *  - **`(1M context)` is inside the model, not stripped.** It is what
+ *    distinguishes the 1M variant, and #1783 already displays the hook-reported
+ *    id verbatim.
+ *
+ * No /g. No nested quantifiers: the lazy `[^\u2500-\u259F]*?` sits between two
+ * literal-anchored parts, and the greedy prefix class is disjoint from `\S`.
+ */
+exports.CLAUDE_STARTUP_BANNER_PATTERN = /^\s*[\u2500-\u259F][\s\u2500-\u259F]*(\S[^\u2500-\u259F]*?)\s+with\s+(minimal|low|medium|high|xhigh)\s+effort\b/i;
+function readClaudeBanner(line) {
+    const match = exports.CLAUDE_STARTUP_BANNER_PATTERN.exec(line);
+    if (!match)
+        return null;
+    const model = match[1].trim();
+    if (!isPlausibleModelLabel(model))
+        return null;
+    return { model, effort: resolveEffortToken(match[2]) };
+}
+// =============================================================================
+// Antigravity
+// =============================================================================
+/**
+ * The two left-hand hints agy prints on its status bar (#1784).
+ *
+ * `? for shortcuts` when idle and `esc to cancel` while generating — both
+ * measured on agy 1.1.13, and both already documented in
+ * `src/lib/cli-tools/antigravity.ts`. Requiring one of them is what stops a
+ * wrapped answer line that happens to end in `· high` from being read as chrome.
+ */
+exports.ANTIGRAVITY_STATUS_BAR_HINT_PATTERN = /^\s*(?:\?\s+for\s+shortcuts|esc\s+to\s+cancel)\b/i;
+/**
+ * Reads `<model> (<Effort>)` off the agy startup banner (#1784).
+ *
+ * Measured: `    ▀▀▀▀▀▀▀▀      Gemini 3.7 Flash (High)`. Same block-glyph anchor
+ * as the Claude banner, for the same reason. The sibling banner lines are
+ * rejected by the effort keyword — the account line `dev@example.com (Google AI
+ * Pro)` sitting directly above it has the shape but not the vocabulary.
+ *
+ * Used only as the fallback: the status bar survives scrollback eviction and the
+ * banner does not.
+ */
+exports.ANTIGRAVITY_BANNER_MODEL_PATTERN = /^\s*[\u2500-\u259F][\s\u2500-\u259F]*(\S[^\u2500-\u259F]*?)\s+\((minimal|low|medium|high|xhigh)\)\s*$/i;
+function readAntigravityStatusBar(line) {
+    if (!exports.ANTIGRAVITY_STATUS_BAR_HINT_PATTERN.test(line))
+        return null;
+    const separator = line.lastIndexOf('·');
+    if (separator < 0)
+        return null;
+    // agy drops the final column of this line (see `resolveEffortToken`), so the
+    // trailing token is read with truncation tolerance. If it does not resolve,
+    // the whole line is abandoned rather than half-read: a bar with no effort
+    // suffix would otherwise hand back a model name with its last letter shaved
+    // off.
+    const effort = resolveEffortToken(line.slice(separator + 1), { allowTruncated: true });
+    if (!effort)
+        return null;
+    // The bar is `<hint>` … right-aligned `<model>`, so the model is the last
+    // run of text separated from the hint by the alignment padding.
+    const chunks = line.slice(0, separator).trimEnd().split(/\s{2,}/);
+    const model = (chunks[chunks.length - 1] ?? '').trim();
+    return { model: isPlausibleModelLabel(model) ? model : null, effort };
+}
+function readAntigravityBanner(line) {
+    const match = exports.ANTIGRAVITY_BANNER_MODEL_PATTERN.exec(line);
+    if (!match)
+        return null;
+    const model = match[1].trim();
+    if (!isPlausibleModelLabel(model))
+        return null;
+    return { model, effort: resolveEffortToken(match[2]) };
+}
+// =============================================================================
+// Public API
+// =============================================================================
+/**
+ * Scan a capture from the bottom up, returning the first line that reads.
+ *
+ * Bottom-up is the whole rule: the status bar is the last line of the frame, and
+ * for Claude "the last banner wins" is how a mid-session `/model` switch — which
+ * prints a fresh banner — overtakes the one from session start.
+ *
+ * ANSI is stripped per line rather than over the whole blob so a malformed OSC
+ * sequence can never swallow a newline and merge two lines into one.
+ */
+function scanFromEnd(captureText, read) {
+    const lines = captureText.split('\n');
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const result = read((0, ansi_1.stripAnsi)(lines[i]));
+        if (result)
+            return result;
+    }
+    return null;
+}
+/**
+ * What this capture says the session's model and reasoning effort are (#1784).
+ *
+ * Pure and side-effect free. Never throws, and answers `{ model: null, effort:
+ * null }` for every tool it has no rule for (gemini / copilot / vibe-local /
+ * opencode — out of scope for this Issue) 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
+ * 2000-line `history-limit`; a Claude session that has been talking for hours
+ * has long since scrolled its banner away, and the honest answer then is "the
+ * screen does not say" — the alternative, a stale or guessed value, is the one
+ * thing this must not do. The caller latches the last non-null sighting.
+ *
+ * @param cliToolId - Which TUI the text came from; the rules are per-tool
+ * @param captureText - `capture-pane` output, ANSI-bearing or not
+ */
+function extractModelInfo(cliToolId, captureText) {
+    if (!captureText)
+        return unknown();
+    switch (cliToolId) {
+        case 'codex':
+            return scanFromEnd(captureText, readCodexFooter) ?? unknown();
+        case 'claude':
+            return scanFromEnd(captureText, readClaudeBanner) ?? unknown();
+        case 'antigravity':
+            return (scanFromEnd(captureText, readAntigravityStatusBar) ??
+                scanFromEnd(captureText, readAntigravityBanner) ??
+                unknown());
+        default:
+            return unknown();
+    }
+}
+/**
+ * The effort an Antigravity model id carries in its own name (#1784).
+ *
+ * agy's ids embed the level — `gemini-3.7-flash-high`, `gemini-3.5-flash-low` —
+ * and that id arrives on **every** agy hook payload (`modelName`), which makes
+ * it a strictly better source than the screen for this one tool: no scrollback
+ * dependency, no truncation, no polling delay.
+ *
+ * Ids that carry no suffix (`claude-sonnet-4-6`, `claude-opus-4-6-thinking`)
+ * answer null and fall through to the scraped bar.
+ *
+ * **Measured against the Issue text**: #1784 lists `gpt-oss-120b-medium` as an
+ * id "without a suffix" while also specifying `-low|-medium|-high$` as the rule
+ * — the two contradict each other, because that id ends in `-medium`. The stated
+ * rule is applied as written (it reads `medium`), which is also the reading that
+ * matches what the level means for that model. Nothing is lost either way: the
+ * *model* shown in the UI is the hook-reported id verbatim, so the id is never
+ * rewritten by this function.
+ *
+ * `minimal` / `xhigh` are deliberately not in the suffix vocabulary: no agy id
+ * has been observed with them, and a model genuinely named `…-minimal` would be
+ * misread.
+ */
+exports.ANTIGRAVITY_MODEL_ID_EFFORT_PATTERN = /-(low|medium|high)$/i;
+function deriveEffortFromModelId(modelId) {
+    if (!modelId)
+        return null;
+    const match = exports.ANTIGRAVITY_MODEL_ID_EFFORT_PATTERN.exec(modelId);
+    return match ? match[1].toLowerCase() : null;
+}
+/**
+ * Fold the hook-reported model together with the scraped frame (#1784).
+ *
+ * The precedence, and why:
+ *
+ *  - **model — hooks win.** A hook payload is the agent naming itself; the
+ *    screen is a render of that, abbreviated for display (agy prints `Gemini 3.7
+ *    Flash` for `gemini-3.7-flash-high`). When they disagree the exact one is
+ *    right. Capture only fills the hole: Claude after a server restart, and any
+ *    session that predates this process.
+ *  - **effort — the screen wins for codex/claude**, because it is the *only*
+ *    source: no hook payload of any tool carries an effort field.
+ *  - **effort — the id wins for antigravity**, because agy encodes the level in
+ *    the id it reports on every event, and that beats a bar that is only on
+ *    screen while the session lives.
+ *
+ * The derivation reads the *merged* model rather than the hook value alone:
+ * effort-in-the-id is a property of the id being published, and when no hook has
+ * spoken the merged value is the scraped display name, which carries no suffix
+ * and falls through to the scraped effort anyway. Same answer, one input.
+ *
+ * @param cliToolId - Which tool; only `antigravity` derives effort from the id
+ * @param hooksModel - {@link import('../../lib/session/agent-event-state').getLastKnownAgentModel}
+ * @param captured - {@link extractModelInfo}'s answer, latched by the caller
+ */
+function mergeModelInfo(cliToolId, hooksModel, captured) {
+    const model = (hooksModel || null) ?? captured?.model ?? null;
+    const capturedEffort = captured?.effort ?? null;
+    const effort = cliToolId === 'antigravity' ? (deriveEffortFromModelId(model) ?? capturedEffort) : capturedEffort;
+    return { model, effort };
+}

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

@@ -198,6 +198,10 @@ exports.antigravityAgentEventSource = (0, define_source_1.definePushHookSource)(
     // protojson camelCase, one tool out of six. `session_id` does not exist here.
     conversationIdFields: ['conversationId'],
     toolCallIdFields: [],
+    // Issue #1783. protojson camelCase again: `modelName`, not `model`. Present on
+    // all six captured fixtures, so agy is the one tool whose model survives every
+    // kind of event — including the ones that carry no session id at all.
+    modelFields: ['modelName'],
     // The tool name is nested under `toolCall`, and it is present on both
     // `PreToolUse` and `PostToolUse` payloads (checked against both fixtures).
     extractDetail: (event, payload) => event === 'pre_tool_use' || event === 'post_tool_use'

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

@@ -109,6 +109,13 @@ exports.claudeAgentEventSource = (0, define_source_1.definePushHookSource)({
     nativeEventNameFields: ['hook_event_name'],
     conversationIdFields: hook_event_vocabulary_1.SESSION_ID_FIELDS,
     toolCallIdFields: hook_event_vocabulary_1.TOOL_CALL_ID_FIELDS,
+    // Issue #1783. Claude sends it on `SessionStart` and nowhere else — checked
+    // against every fixture in `tests/fixtures/hooks/claude/`, where only
+    // `session-start.json` carries the key. So the value has to be *remembered*
+    // rather than read off the newest event; `getLastKnownAgentModel` is what
+    // does that. The value arrives with its own suffix (`claude-opus-5[1m]`) and
+    // is not parsed here: a display string the tool chose is the tool's to spell.
+    modelFields: ['model'],
     // S2.
     extractDetail: hook_event_vocabulary_1.extractSnakeCaseEventDetail,
     // S7. Both parsers are strict and answer null for anything they cannot vouch

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

@@ -107,6 +107,11 @@ exports.codexAgentEventSource = (0, define_source_1.definePushHookSource)({
     nativeEventNameFields: ['hook_event_name'],
     conversationIdFields: hook_event_vocabulary_1.SESSION_ID_FIELDS,
     toolCallIdFields: hook_event_vocabulary_1.TOOL_CALL_ID_FIELDS,
+    // Issue #1783. Same spelling as Claude, but on every event except `SessionEnd`
+    // rather than on `SessionStart` alone — verified against the fixtures, where
+    // only `session-end.json` lacks the key. codex therefore keeps its model
+    // visible through a restart of this server, which claude does not.
+    modelFields: ['model'],
     extractDetail: hook_event_vocabulary_1.extractSnakeCaseEventDetail,
     // The captured `PermissionRequest` payload is Claude-shaped field for field —
     // `hook_event_name`, `tool_name`, `tool_input`, `session_id`,

package/dist/server/src/lib/hooks/sources/define-source.js

@@ -67,6 +67,8 @@ function definePushHookSource(spec) {
                     detail: spec.extractDetail,
                     conversationId: spec.conversationIdFields,
                     toolCallId: spec.toolCallIdFields,
+                    modelFields: spec.modelFields,
+                    extractModel: spec.extractModel,
                 });
             }
             const mapping = (0, event_mapper_1.runEventMappers)(spec.mappers, nativeEventName, raw.payload);
@@ -80,6 +82,8 @@ function definePushHookSource(spec) {
                 detail: spec.extractDetail,
                 conversationId: spec.conversationIdFields,
                 toolCallId: spec.toolCallIdFields,
+                modelFields: spec.modelFields,
+                extractModel: spec.extractModel,
             });
         },
         parsePermissionRequest: spec.parsePermissionRequest,
@@ -136,6 +140,8 @@ function definePullEventSource(spec) {
                     detail: spec.extractDetail,
                     conversationId: spec.conversationIdFields,
                     toolCallId: spec.toolCallIdFields,
+                    modelFields: spec.modelFields,
+                    extractModel: spec.extractModel,
                 });
             }
             const mapping = (0, event_mapper_1.runEventMappers)(spec.mappers, nativeEventName, raw.payload);
@@ -147,6 +153,8 @@ function definePullEventSource(spec) {
                 detail: spec.extractDetail,
                 conversationId: spec.conversationIdFields,
                 toolCallId: spec.toolCallIdFields,
+                modelFields: spec.modelFields,
+                extractModel: spec.extractModel,
             });
         },
         parsePermissionRequest: spec.parsePermissionRequest,

package/dist/server/src/lib/hooks/sources/event-mapper.js

@@ -33,6 +33,7 @@ exports.resetUnknownEventTallies = resetUnknownEventTallies;
 exports.readStringField = readStringField;
 exports.readFirstStringField = readFirstStringField;
 exports.boundDetail = boundDetail;
+exports.boundModel = boundModel;
 exports.isPlainObject = isPlainObject;
 exports.readNestedString = readNestedString;
 exports.buildNormalizedEvent = buildNormalizedEvent;
@@ -118,6 +119,20 @@ function boundDetail(value) {
         return null;
     return value.slice(0, agent_event_types_1.MAX_EVENT_DETAIL_LENGTH);
 }
+/**
+ * Trim a model id to the length the store accepts (Issue #1783).
+ *
+ * The same bound as {@link boundDetail} and deliberately so: both are short
+ * enum-ish words the agent chose, both end up rendered, and giving the model its
+ * own number would only invite the two to drift. Named separately because the
+ * call sites read better and because a future measurement could move one
+ * without moving the other.
+ */
+function boundModel(value) {
+    if (value === null || value === '')
+        return null;
+    return value.slice(0, agent_event_types_1.MAX_EVENT_DETAIL_LENGTH);
+}
 /** Type guard for a JSON object (not an array, not null). */
 function isPlainObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
@@ -151,6 +166,11 @@ function buildNormalizedEvent(mapping, payload, receivedAt, fallbacks = {}) {
             (fallbacks.conversationId ? readFirstStringField(payload, fallbacks.conversationId) : null),
         toolCallId: mapping.toolCallId ??
             (fallbacks.toolCallId ? readFirstStringField(payload, fallbacks.toolCallId) : null),
+        // Issue #1783. Every source runs through here, so a tool that declares
+        // neither hook simply answers null — which is the honest answer for gemini
+        // and copilot, whose payloads never carry one.
+        model: boundModel(fallbacks.extractModel?.(payload) ??
+            (fallbacks.modelFields ? readFirstStringField(payload, fallbacks.modelFields) : null)),
         raw: payload,
         receivedAt,
     };

package/dist/server/src/lib/hooks/sources/opencode/ingest.js

@@ -230,6 +230,12 @@ async function ingestOpencodeEvent(target, event) {
             detail: event.detail?.slice(0, agent_event_types_1.MAX_EVENT_DETAIL_LENGTH) ?? null,
             sessionId: event.conversationId,
             message: describeNotification(event)?.slice(0, structured_prompt_1.MAX_STRUCTURED_PROMPT_MESSAGE_LENGTH) ?? null,
+            // Issue #1783. The second of the two receiving paths — this one is
+            // in-process rather than an HTTP route, and forgetting it would leave
+            // opencode as the one tool whose model is extracted and then dropped.
+            // Already bounded by the normaliser; null on the frames that carry no
+            // `properties.info.model` (every `session.idle`, every tool part).
+            model: event.model,
         });
         if (event.event === 'notification' && event.detail === mappers_1.OPENCODE_PERMISSION_DETAIL) {
             await adjudicatePermission(target, event, instanceId);

package/dist/server/src/lib/hooks/sources/opencode/mappers.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.OPENCODE_MAPPERS = exports.OPENCODE_ERROR_DETAIL = exports.OPENCODE_QUESTION_DETAIL = exports.OPENCODE_PERMISSION_DETAIL = void 0;
 exports.frameProperties = frameProperties;
 exports.frameSessionId = frameSessionId;
+exports.frameModel = frameModel;
 exports.partToolName = partToolName;
 exports.partCallId = partCallId;
 exports.withConversationId = withConversationId;
@@ -69,6 +70,27 @@ function frameProperties(payload) {
 function frameSessionId(payload) {
     return (0, event_mapper_1.readNestedString)(frameProperties(payload), ['sessionID']);
 }
+/**
+ * `properties.info.model` — the model this frame's session/message ran on (#1783).
+ *
+ * Two spellings, both live, and the Issue text only named the first: a
+ * `message.updated` frame carries `{ providerID, modelID }` while
+ * `session.created` / `session.deleted` carry `{ id, providerID }`. Checked
+ * against the captured fixtures, which is the only specification that has been
+ * right about this server so far (its own `/doc` omits `server.heartbeat`).
+ * Reading `modelID` alone would have left `session_start` — the one event a
+ * fresh subscription is guaranteed to see — with no model at all.
+ *
+ * `providerID` is deliberately not folded in. `github-copilot/claude-sonnet-4.6`
+ * would be a *composed* string, and every other tool reports the bare model, so
+ * composing here would make opencode the odd one out in the UI for no gain.
+ */
+function frameModel(payload) {
+    const info = frameProperties(payload).info;
+    if (!(0, event_mapper_1.isPlainObject)(info))
+        return null;
+    return (0, event_mapper_1.readNestedString)(info, ['model', 'modelID']) ?? (0, event_mapper_1.readNestedString)(info, ['model', 'id']);
+}
 /** `properties.part.state.status` — `pending` / `running` / `completed` / `error`. */
 function partStatus(payload) {
     return (0, event_mapper_1.readNestedString)(frameProperties(payload), ['part', 'state', 'status']);

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

@@ -238,6 +238,9 @@ exports.opencodeAgentEventSource = (0, define_source_1.definePullEventSource)({
     nativeEventNameFields: ['type'],
     // Flat lookup cannot reach `properties.sessionID`; the rules fill it in.
     conversationIdFields: [],
+    // Issue #1783: nor `properties.info.model.*`, so the spec takes the reader
+    // instead of a key list. See {@link frameModel} for the two spellings.
+    extractModel: mappers_1.frameModel,
     parsePermissionRequest: payloads_1.parseOpencodePermissionRequest,
     parseQuestion: payloads_1.parseOpencodeQuestion,
     // Self-reference resolves at call time, which is after this const is bound.

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

@@ -28,7 +28,20 @@ const prompt_dedup_1 = require("./prompt-dedup");
 const response_dedup_1 = require("./response-dedup");
 const response_poller_core_1 = require("./response-poller-core");
 const push_1 = require("../../lib/push");
+// Issue #1790: imported by deep path, not through `@/lib/push`. Suites that
+// replace the barrel to count notifications (e.g. the #1547 escalation test)
+// would otherwise get `undefined` here and take down module evaluation.
+const waiting_push_notifier_1 = require("../../lib/push/waiting-push-notifier");
+const waiting_episode_state_1 = require("../../lib/session/waiting-episode-state");
 const task_transition_service_1 = require("../../lib/tasks/task-transition-service");
+// Issue #1790: arm the waiting-edge push subscription.
+//
+// It has to exist before the first edge, and `server.ts` reaches this module at
+// boot (it imports `polling/response-poller` for `stopAllPolling`, which pulls
+// in `response-poller-core` and then this file), so this is the earliest hook
+// the notification path owns. Idempotent by replacement, and it starts no timer
+// and touches no database until a wait actually opens.
+(0, waiting_push_notifier_1.startWaitingPushNotifier)();
 /**
  * Creates an incomplete extraction result with empty response.
  * Centralizes the repeated pattern of returning an in-progress/incomplete state.
@@ -465,13 +478,39 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
             });
             // Web Push fan-out (Issue #1125): agent is now waiting for a prompt reply.
             // Fire-and-forget — push is advisory and must never block/break the poller.
+            //
+            // Issue #1790: the wait is now named by #1786's episode rather than by the
+            // prompt text. The two lines below are ordered, not incidental:
+            //
+            //  1. the notification is raised first, while it still has the prompt's
+            //     own question to quote — it records the episode in the dedup, so
+            //     whichever path reports the wait second says nothing;
+            //  2. `observeWaitingEdge` then opens that same episode, which is what
+            //     lets the edge listener (and #1788's WebSocket frame) agree with this
+            //     call about *which* wait this is instead of raising a second one.
+            //
+            // Both use one timestamp so the episode the notification claims and the
+            // episode the store opens are the same number.
+            const promptObservedAt = Date.now();
+            const promptWaitingSince = (0, waiting_episode_state_1.getWaitingEpisode)(worktreeId, cliToolId, instanceId)?.since ?? promptObservedAt;
             void (0, push_1.notifyPushSubscribers)({
                 worktreeId,
                 worktreeName: worktree.name,
                 kind: 'prompt',
                 agentName: resolvedInstanceId,
+                instanceId: resolvedInstanceId,
+                waitingKind: 'prompt',
+                waitingSince: promptWaitingSince,
                 excerpt: promptDetection.promptData?.question ?? promptSaveContent,
             }).catch(() => { });
+            (0, waiting_episode_state_1.observeWaitingEdge)({
+                worktreeId,
+                cliToolId,
+                instanceId,
+                waiting: true,
+                kind: 'prompt',
+                now: promptObservedAt,
+            });
             if (!isFullScreenTui) {
                 (0, response_poller_core_1.stopPolling)(worktreeId, cliToolId, instanceId);
             }
@@ -562,6 +601,14 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
         });
         // Broadcast message to WebSocket clients
         (0, ws_server_1.broadcastMessage)('message', { worktreeId, message });
+        // Issue #1790: the agent has just produced a reply, so whatever it was
+        // waiting for is over. Closing the episode here is what makes a *second*
+        // prompt in the same session notify again: without it a wait opened by the
+        // prompt branch above could stay open until a browser next probes the status
+        // API, and every later prompt would be folded into that stale episode and
+        // silently deduped. Nothing to close is a no-op, and no notification is
+        // raised for a closing edge.
+        (0, waiting_episode_state_1.observeWaitingEdge)({ worktreeId, cliToolId, instanceId, waiting: false });
         // Web Push fan-out (Issue #1125): session completed (running → idle).
         // Fire-and-forget — push is advisory and must never block/break the poller.
         void (0, push_1.notifyPushSubscribers)({