commandmate 0.27.1 → 0.28.0

package/dist/server/src/lib/db/migrations/index.js

@@ -40,6 +40,9 @@ const v53_worktree_aliases_1 = require("./v53-worktree-aliases");
 const v54_worktree_id_path_derived_1 = require("./v54-worktree-id-path-derived");
 const v55_compact_churned_worktree_ids_1 = require("./v55-compact-churned-worktree-ids");
 const v56_gate_result_source_1 = require("./v56-gate-result-source");
+const v57_push_subscription_defaults_notice_1 = require("./v57-push-subscription-defaults-notice");
+const v58_agent_session_costs_1 = require("./v58-agent-session-costs");
+const v59_opencode_instance_settings_1 = require("./v59-opencode-instance-settings");
 /**
  * Complete ordered list of all migrations.
  * Used internally by the barrel file (db-migrations.ts); NOT exported from the barrel (DR2-004).
@@ -83,4 +86,7 @@ exports.migrations = [
     ...v54_worktree_id_path_derived_1.v54_migrations,
     ...v55_compact_churned_worktree_ids_1.v55_migrations,
     ...v56_gate_result_source_1.v56_migrations,
+    ...v57_push_subscription_defaults_notice_1.v57_migrations,
+    ...v58_agent_session_costs_1.v58_migrations,
+    ...v59_opencode_instance_settings_1.v59_migrations,
 ];

package/dist/server/src/lib/db/migrations/runner.js

@@ -17,7 +17,7 @@ const path_1 = __importDefault(require("path"));
  * Current schema version
  * Increment this when adding new migrations
  */
-exports.CURRENT_SCHEMA_VERSION = 56;
+exports.CURRENT_SCHEMA_VERSION = 59;
 /**
  * Get current schema version from database
  */

package/dist/server/src/lib/db/migrations/v57-push-subscription-defaults-notice.js

@@ -0,0 +1,54 @@
+"use strict";
+/**
+ * Migration v57: mark which generation of *defaults* a push subscription was
+ * created under (Issue #2056).
+ *
+ * Epic #2002's completion criteria do not both hold for rows that already
+ * exist. Criterion 3 wants ordinary completions to be off by default; criterion
+ * 6 wants no notification to stop unintentionally. A migration that flipped
+ * `enabled_completion` to 0 across the table satisfies the first and breaks the
+ * second — "my notifications went quiet" is indistinguishable from "my
+ * notifications broke". Doing nothing satisfies the second and breaks the first.
+ *
+ * The way out is consent: tell the reader, and let them choose. Then the change
+ * is no longer *unintentional* and both criteria hold. This column is the only
+ * schema that costs — it records whether this device has been told.
+ *
+ * **This migration changes no notification behaviour whatsoever.** Nothing reads
+ * `defaults_version` when fanning out: {@link getPushSubscriptionsForKind} and
+ * {@link countPushSubscriptionsForKind} still filter on `enabled_prompt` /
+ * `enabled_completion` alone. Applying it stops zero notifications and starts
+ * zero notifications — which is exactly what criterion 6 asks for, and what
+ * `push-subscription-defaults-notice-2056.test.ts` asserts by counting the
+ * fan-out on both sides of the migration.
+ *
+ * `NOT NULL DEFAULT 0` is the whole trick. SQLite backfills the constant into
+ * every existing row, and 0 means "created before #2000 changed the defaults" —
+ * precisely the population that was never told. `upsertPushSubscription()` binds
+ * `PUSH_DEFAULTS_VERSION` on INSERT, so rows created from here on start already
+ * informed, and the `ON CONFLICT` clause deliberately leaves the column alone so
+ * that a legacy device re-registering does not silently mark itself as told.
+ *
+ * The rollback is real, like v42's and unlike v35/v40's no-ops: `DROP COLUMN`
+ * has been supported since SQLite 3.35 and this column carries no index and no
+ * constraint, so the drop needs no table rebuild.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.v57_migrations = void 0;
+exports.v57_migrations = [
+    {
+        version: 57,
+        name: 'add-defaults-version-to-push-subscriptions',
+        up: (db) => {
+            db.exec(`
+        ALTER TABLE push_subscriptions
+          ADD COLUMN defaults_version INTEGER NOT NULL DEFAULT 0;
+      `);
+        },
+        down: (db) => {
+            db.exec(`
+        ALTER TABLE push_subscriptions DROP COLUMN defaults_version;
+      `);
+        },
+    },
+];

package/dist/server/src/lib/db/migrations/v58-agent-session-costs.js

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * Migration v58: a durable ledger of what each agent session has spent
+ * (Issue #2044).
+ *
+ * ## Why the numbers need a table at all
+ *
+ * Issue #2040 already reads `session.updated` off opencode's SSE stream and
+ * keeps `{ cost, tokens }` per instance in `lib/hooks/agent-session-telemetry`.
+ * That record is **in memory and dies with the subscription** — killing the pane
+ * drops it — which is exactly right for what it publishes
+ * (`structuredEvents.session`, "what is this conversation costing *now*") and
+ * useless for what a daily report asks ("what did today cost"). A report
+ * generated at 18:00 would see nothing of a session that ended at noon.
+ *
+ * So the ledger is a *sampler's* table, not a second event mapping: nothing here
+ * subscribes to anything, and no `session.updated` writer is added. A sampler
+ * copies the live record in, keyed by the agent's own session id.
+ *
+ * ## Why `session_id` is the primary key, and why writes overwrite
+ *
+ * `Session.cost` and `Session.tokens` are **cumulative for the session**, not
+ * per-turn. Measured on opencode 1.18.22 in an isolated `HOME`
+ * (`docs/design/opencode-server-live-verification.md` §15): a session whose two
+ * steps reported `0.03372225` and `0.0038181` answered `cost: 0.03754035` on
+ * `GET /session`, and summing the two sessions in that project reproduced
+ * `opencode stats --project ""`'s `Total Cost` ($0.07), `Input` (6),
+ * `Output` (181), `Cache Read` (8.4K) and `Cache Write` (16.7K) exactly.
+ *
+ * That makes last-write-wins the only correct rule: **accumulating** samples
+ * would multiply a long-running session's cost by however many times the
+ * sampler happened to look at it. `ON CONFLICT(session_id) DO UPDATE` is
+ * therefore load-bearing rather than defensive, and it is what lets the sampler
+ * run on any schedule at all without the totals depending on its period.
+ *
+ * ## Column notes
+ *
+ * - **`date`** is the local calendar day the session was *first sampled*, in the
+ *   `YYYY-MM-DD` spelling `daily_reports.date` uses, so the report's day and the
+ *   ledger's day are the same string. `first_seen_at` keeps the instant. A
+ *   session spanning midnight stays on its opening day rather than being split:
+ *   the agent reports one cumulative number and there is no honest way to
+ *   apportion it across two days.
+ * - **every numeric column is nullable**, and null means "the agent did not
+ *   say", never zero — the rule `AgentSessionTokenUsage` states. A session that
+ *   has not run a turn publishes no counts, and storing `0` would make this
+ *   database assert a measurement nobody took.
+ * - **`worktree_id`** is spelled conventionally so `getWorktreeChildTables()`
+ *   finds it by introspection: the row then follows a worktree id rename
+ *   (v54/v55) and is swept when the worktree is deleted, the same lifetime
+ *   `chat_messages` has. The ledger describes what a worktree spent, so it has
+ *   no meaning once that worktree is gone — and a report already generated for
+ *   that day keeps its text in `daily_reports` regardless. Deliberately **not**
+ *   an append-only ledger: `skill_operations`-style `BEFORE UPDATE` triggers
+ *   would forbid the overwrite the paragraph above requires.
+ *
+ * The rollback drops the table, which is the whole of what this migration adds.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.v58_migrations = void 0;
+exports.v58_migrations = [
+    {
+        version: 58,
+        name: 'agent-session-costs',
+        up: (db) => {
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS agent_session_costs (
+          session_id TEXT PRIMARY KEY,
+          worktree_id TEXT NOT NULL,
+          cli_tool_id TEXT NOT NULL,
+          instance_id TEXT,
+          date TEXT NOT NULL,
+          title TEXT,
+          agent TEXT,
+          model TEXT,
+          provider TEXT,
+          cost REAL,
+          tokens_input INTEGER,
+          tokens_output INTEGER,
+          tokens_reasoning INTEGER,
+          tokens_cache_read INTEGER,
+          tokens_cache_write INTEGER,
+          first_seen_at INTEGER NOT NULL,
+          observed_at INTEGER NOT NULL,
+
+          FOREIGN KEY (worktree_id) REFERENCES worktrees(id) ON DELETE CASCADE
+        );
+      `);
+            // The daily report's only query shape: one day, grouped by worktree.
+            db.exec(`
+        CREATE INDEX IF NOT EXISTS idx_agent_session_costs_date
+        ON agent_session_costs(date, worktree_id);
+      `);
+        },
+        down: (db) => {
+            db.exec('DROP INDEX IF EXISTS idx_agent_session_costs_date;');
+            db.exec('DROP TABLE IF EXISTS agent_session_costs;');
+        },
+    },
+];

package/dist/server/src/lib/db/migrations/v59-opencode-instance-settings.js

@@ -0,0 +1,71 @@
+"use strict";
+/**
+ * Migration v59: what each opencode instance should be launched with (#2048).
+ *
+ * ## Why a table of its own rather than columns on `agent_instances`
+ *
+ * `setAgentInstances` is a **replace**: `PATCH /api/worktrees/[id]` sends the
+ * whole roster and the write deletes every row for the worktree and re-inserts
+ * from the payload. That payload is `AgentInstance[]` — id, tool, alias, order —
+ * and nothing else, so a `model` column on that table would be silently reset to
+ * null every time the operator renamed an instance or dragged one up the list.
+ * A separate table survives the replace, and `pruneOpencodeInstanceSettings`
+ * removes the rows whose instance genuinely went away.
+ *
+ * It is also the only shape that keeps `agentInstances`'s validator and its API
+ * contract unchanged, which Issue #2048's second acceptance condition
+ * ("claude / codex の instance 設定 UI とスナップショットが不変") asks for
+ * directly.
+ *
+ * ## Column notes
+ *
+ * - **All four settings are nullable and null means "not chosen"**, never a
+ *   default. The launcher omits the flag entirely for a null, so an instance
+ *   with a row full of nulls launches byte-identically to one with no row.
+ * - **`provider_id` / `model_id` are two columns, not one string.** `-m` takes
+ *   `provider/model`, but model ids themselves contain slashes
+ *   (`qwen/qwen3-coder-30b`, measured on LMStudio), so a single column could not
+ *   be split back apart.
+ * - **`variant` is stored even though no launch flag can carry it.** The TUI has
+ *   no `--variant` (measured on 1.18.22, §20.3); it is applied on the prompt
+ *   this server posts, which is a per-turn decision that still needs a durable
+ *   place to be decided *once*.
+ * - **`worktree_id` is spelled conventionally** so `getWorktreeChildTables()`
+ *   finds it by introspection: the row then follows a worktree id rename
+ *   (v54/v55) and is swept when the worktree is deleted, which is the lifetime a
+ *   per-instance setting should have.
+ *
+ * The primary key is `(worktree_id, instance_id)` — the same identity
+ * `agent_instances` uses — and the `cli_tool_id` is not part of it: an instance
+ * id belongs to one tool by construction (`resolveInstanceCliTool`), so a
+ * composite including it would let one instance hold two contradictory rows.
+ *
+ * The rollback drops the table, which is the whole of what this migration adds.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.v59_migrations = void 0;
+exports.v59_migrations = [
+    {
+        version: 59,
+        name: 'opencode-instance-settings',
+        up: (db) => {
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS opencode_instance_settings (
+          worktree_id TEXT NOT NULL,
+          instance_id TEXT NOT NULL,
+          agent TEXT,
+          provider_id TEXT,
+          model_id TEXT,
+          variant TEXT,
+          updated_at INTEGER NOT NULL,
+
+          PRIMARY KEY (worktree_id, instance_id),
+          FOREIGN KEY (worktree_id) REFERENCES worktrees(id) ON DELETE CASCADE
+        );
+      `);
+        },
+        down: (db) => {
+            db.exec('DROP TABLE IF EXISTS opencode_instance_settings;');
+        },
+    },
+];

package/dist/server/src/lib/db/push-subscriptions-db.js

@@ -8,12 +8,13 @@
  * be logged — callers pass these straight through without logging.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NEW_SUBSCRIPTION_DEFAULTS = void 0;
+exports.PUSH_DEFAULTS_VERSION = exports.NEW_SUBSCRIPTION_DEFAULTS = void 0;
 exports.upsertPushSubscription = upsertPushSubscription;
 exports.getPushSubscriptionByEndpoint = getPushSubscriptionByEndpoint;
 exports.getAllPushSubscriptions = getAllPushSubscriptions;
 exports.getPushSubscriptionsForKind = getPushSubscriptionsForKind;
 exports.countPushSubscriptionsForKind = countPushSubscriptionsForKind;
+exports.pushSubscriptionNeedsDefaultsNotice = pushSubscriptionNeedsDefaultsNotice;
 exports.updatePushSubscriptionPreferences = updatePushSubscriptionPreferences;
 exports.deletePushSubscriptionByEndpoint = deletePushSubscriptionByEndpoint;
 const crypto_1 = require("crypto");
@@ -56,6 +57,31 @@ exports.NEW_SUBSCRIPTION_DEFAULTS = {
     enabledPrompt: true,
     enabledCompletion: false,
 };
+/**
+ * The generation of *defaults* a stored subscription was created under
+ * (Issue #2056).
+ *
+ * `NEW_SUBSCRIPTION_DEFAULTS` above only ever reaches an INSERT, and #2000
+ * decided — correctly — that existing rows must not move. The consequence is a
+ * population that Epic #2002 never spoke to: devices subscribed before the
+ * change still have completions ON, and the `failure` kind quietly joined their
+ * `enabled_prompt` bucket via {@link KIND_COLUMN}. Their notification volume
+ * went *up* under an Epic whose point was to bring it down, and nothing in the
+ * app said so.
+ *
+ * This counter is how a row remembers whether it has been told. It governs a
+ * one-off notice in the settings UI and nothing else — **no fan-out query reads
+ * it**, so bumping it neither starts nor stops a single notification.
+ *
+ *  - `0` — written by the v57 backfill: created before #2000, never told.
+ *  - `1` — created under the #2000 defaults, or told about them and given the
+ *    choice to adopt or keep (see {@link updatePushSubscriptionPreferences}).
+ *
+ * Raise this (and add a notice for the new step) the next time a *default*
+ * changes under readers who already subscribed. It is deliberately a version
+ * rather than a boolean for that reason.
+ */
+exports.PUSH_DEFAULTS_VERSION = 1;
 function mapRow(row) {
     return {
         id: row.id,
@@ -65,13 +91,14 @@ function mapRow(row) {
         enabledPrompt: row.enabled_prompt === 1,
         enabledCompletion: row.enabled_completion === 1,
         locale: row.locale,
+        defaultsVersion: row.defaults_version,
         createdAt: new Date(row.created_at),
         updatedAt: new Date(row.updated_at),
     };
 }
 const SELECT_COLUMNS = `
   id, endpoint, p256dh, auth, device_label,
-  enabled_prompt, enabled_completion, locale, created_at, updated_at
+  enabled_prompt, enabled_completion, locale, defaults_version, created_at, updated_at
 `;
 /**
  * Create or update a subscription keyed by endpoint. On conflict the encryption
@@ -81,6 +108,12 @@ const SELECT_COLUMNS = `
  * Locale follows the keys, not the preferences: a re-registration carries the
  * reader's current language, so a resolved locale overwrites the stored one.
  * An *unresolved* locale must not clobber a good stored value, hence COALESCE.
+ *
+ * `defaults_version` follows the preferences, not the keys (Issue #2056): the
+ * ON CONFLICT clause leaves it untouched on purpose. A device that subscribed
+ * before #2000 and merely re-registers (a rotated key, a new label) has still
+ * not been told the defaults changed, so marking it as told here would swallow
+ * the notice for exactly the readers it exists for.
  */
 function upsertPushSubscription(db, input) {
     const now = Date.now();
@@ -89,16 +122,16 @@ function upsertPushSubscription(db, input) {
     db.prepare(`
     INSERT INTO push_subscriptions (
       id, endpoint, p256dh, auth, device_label,
-      enabled_prompt, enabled_completion, locale, created_at, updated_at
+      enabled_prompt, enabled_completion, locale, defaults_version, created_at, updated_at
     )
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     ON CONFLICT(endpoint) DO UPDATE SET
       p256dh = excluded.p256dh,
       auth = excluded.auth,
       device_label = excluded.device_label,
       locale = COALESCE(excluded.locale, push_subscriptions.locale),
       updated_at = excluded.updated_at
-  `).run((0, crypto_1.randomUUID)(), input.endpoint, input.p256dh, input.auth, deviceLabel, exports.NEW_SUBSCRIPTION_DEFAULTS.enabledPrompt ? 1 : 0, exports.NEW_SUBSCRIPTION_DEFAULTS.enabledCompletion ? 1 : 0, locale, now, now);
+  `).run((0, crypto_1.randomUUID)(), input.endpoint, input.p256dh, input.auth, deviceLabel, exports.NEW_SUBSCRIPTION_DEFAULTS.enabledPrompt ? 1 : 0, exports.NEW_SUBSCRIPTION_DEFAULTS.enabledCompletion ? 1 : 0, locale, exports.PUSH_DEFAULTS_VERSION, now, now);
     const record = getPushSubscriptionByEndpoint(db, input.endpoint);
     if (!record) {
         throw new Error('Failed to persist push subscription');
@@ -143,6 +176,17 @@ function countPushSubscriptionsForKind(db, kind) {
         .get();
     return row.total;
 }
+/**
+ * Whether this device is still owed the one-off "the defaults changed" notice
+ * (Issue #2056).
+ *
+ * Derived rather than stored as a flag so that raising
+ * {@link PUSH_DEFAULTS_VERSION} for a future change re-arms the notice for every
+ * row at once, including rows that acknowledged the previous one.
+ */
+function pushSubscriptionNeedsDefaultsNotice(record) {
+    return record.defaultsVersion < exports.PUSH_DEFAULTS_VERSION;
+}
 /** Update per-type preferences for a subscription. Returns the updated record or null. */
 function updatePushSubscriptionPreferences(db, endpoint, prefs) {
     const assignments = ['updated_at = ?'];
@@ -155,6 +199,13 @@ function updatePushSubscriptionPreferences(db, endpoint, prefs) {
         assignments.push('enabled_completion = ?');
         params.push(prefs.enabledCompletion ? 1 : 0);
     }
+    // One-way: acknowledging cannot un-acknowledge. Nothing in the product asks
+    // to replay the notice, and a `false` here would let a stale client payload
+    // reopen a decision the reader has already made.
+    if (prefs.acknowledgeDefaultsNotice) {
+        assignments.push('defaults_version = ?');
+        params.push(exports.PUSH_DEFAULTS_VERSION);
+    }
     params.push(endpoint);
     db.prepare(`UPDATE push_subscriptions SET ${assignments.join(', ')} WHERE endpoint = ?`).run(...params);
     return getPushSubscriptionByEndpoint(db, endpoint);

package/dist/server/src/lib/detection/cli-patterns.js

@@ -1091,12 +1091,23 @@ function stripOpenCodeGutter(row) {
  * produce without touching the operator's real credentials), and the header's
  * own hatch is already the affordance.
  *
- * The header allowlist is deliberately unchanged. opencode 1.18 draws the same
- * chrome for its ctrl+p command palette (`Commands … esc`), which this pattern
- * therefore still does not match; that frame lands on `running` / `default`
- * (measured, `opencode-live-1896/command-palette.txt`) -- i.e. on the
- * "no evidence" side, which #1708's unclassified-frame guard already covers.
- * Widening the allowlist is a separate change with its own live frames.
+ * The header allowlist is deliberately unchanged, and Issue #2112 kept it that
+ * way rather than adding the five headings it found missing (`Select agent`,
+ * `Sessions`, `Timeline`, `Commands`, and the palette's). #1896 left the
+ * question as "a separate change with its own live frames"; #2046 supplied the
+ * frames and the answer they gave is that a WIDER WORD LIST is the wrong shape.
+ * Three of those dialogs published `ready` / `opencode_response_complete` — the
+ * marker of the previous turn, still on the pane behind the overlay — so the
+ * damage was a false COMPLETION, not a missing NavigationButtons row, and no
+ * heading added here would have changed that ordering. The fix is a gate ahead
+ * of the completion branch that reads the overlay's LAYOUT
+ * (`lib/detection/opencode-modal-overlay.ts`, branch C2 of
+ * `tools/opencode/detect.ts`), which is also what keeps the prose false
+ * positives this pattern was narrowed for from coming back through a longer
+ * list.
+ *
+ * This pattern still runs, and still first: it is the reading that survives ANSI
+ * stripping, where the layout rule cannot see anything at all.
  *
  * The whitespace runs are `[^\S\n]` (horizontal only) for the reason Issue #1883
  * documents: plain `\s` crosses newlines under the `m` flag, which would let a

package/dist/server/src/lib/detection/excerpt.js

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * Byte-budgeted excerpt truncation for published detection fields (Issue #2095).
+ *
+ * Extracted from `upstream-faults.ts`, which has carried this since Issue #1839,
+ * because #2095 publishes a second screen-read excerpt (`paneObstruction`) under
+ * the same rules. Two copies of a bound whose whole job is to be exact is how the
+ * two fields would come to promise different things while claiming the same
+ * limit — the same argument `status-evidence.ts` makes for keeping one
+ * expression per fact.
+ *
+ * A leaf module by design: it imports nothing, so the canary (which runs outside
+ * Next), the server payload builder and the client components can all share it.
+ *
+ * @module lib/detection/excerpt
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.truncateToByteBudget = truncateToByteBudget;
+/**
+ * Truncate to a UTF-8 **byte** budget on a code-point boundary.
+ *
+ * Bytes rather than characters for the reason Issue #1694 gives for its own
+ * excerpt: a Japanese frame runs three bytes to the character, so a
+ * character-counted bound publishes three times the payload it promises. These
+ * excerpts ride every `current-output` response of an affected session, and
+ * those responses are polled every few seconds.
+ *
+ * The marker is inside the budget, not on top of it: the bound is a promise
+ * about the published field, and a caller sizing a log line by it must not be
+ * handed twelve more characters than it asked for. Accumulating code points
+ * (never UTF-16 units) is what keeps a surrogate pair whole.
+ */
+function truncateToByteBudget(text, maxBytes, marker) {
+    const encoder = new TextEncoder();
+    if (encoder.encode(text).length <= maxBytes)
+        return text;
+    const budget = maxBytes - encoder.encode(marker).length;
+    let bytes = 0;
+    let out = '';
+    for (const char of text) {
+        const size = encoder.encode(char).length;
+        if (bytes + size > budget)
+            break;
+        bytes += size;
+        out += char;
+    }
+    return `${out}${marker}`;
+}

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

@@ -406,6 +406,18 @@ function sameModel(a, b) {
  * live frames, so `effort` is always null here. That is not a gap in this
  * reader: the number is not on screen to read.
  *
+ * **Issue #2048 re-measured this on 1.18.22 and it still holds — the effort was
+ * never on the pane, and now it does not need to be.** A session deliberately
+ * run at `variant: high` printed `▣  Build · Claude Sonnet 4.6 · 2.3s` on the
+ * step row and `Plan · Claude Haiku 4.5 (latest) GitHub Copilot` on the composer
+ * footer: neither surface gained a variant
+ * (`docs/design/opencode-server-live-verification.md` §20.4). The value arrives
+ * on the *structured* channel instead — `Session.model.variant` and
+ * `message.updated.info.variant` — and is latched by
+ * `agent-event-state`'s `recordAgentReportedEffort`, which {@link mergeModelInfo}
+ * now ranks above everything this module can see. So the null below is still the
+ * honest answer for the screen, and the display is no longer limited by it.
+ *
  * ## Why not the footer model bar
  *
  * The Issue also names `Build · <model> GitHub Copilot` — the bar two rows above
@@ -557,6 +569,13 @@ function deriveEffortFromModelId(modelId) {
  *  - **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.
+ *  - **effort — the agent's own word wins outright when it said one**
+ *    (Issue #2048). opencode publishes a `variant` on the frames CommandMate is
+ *    subscribed to, and that is the agent naming its own reasoning effort — the
+ *    same argument the model half makes for hooks beating the screen, applied to
+ *    the half #1784 had no hook source for. It ranks above the antigravity
+ *    derivation as well, because a tool that states the value has not left it to
+ *    be inferred from an id.
  *
  * 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
@@ -566,10 +585,14 @@ function deriveEffortFromModelId(modelId) {
  * @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
+ * @param hooksEffort - {@link import('../../lib/session/agent-event-state').getLastReportedAgentEffort}
+ *   (Issue #2048). Optional and last so every pre-#2048 call site is unchanged,
+ *   and null for every tool that publishes no effort — which is all of them but
+ *   opencode.
  */
-function mergeModelInfo(cliToolId, hooksModel, captured) {
+function mergeModelInfo(cliToolId, hooksModel, captured, hooksEffort) {
     const model = (hooksModel || null) ?? captured?.model ?? null;
     const capturedEffort = captured?.effort ?? null;
-    const effort = cliToolId === 'antigravity' ? (deriveEffortFromModelId(model) ?? capturedEffort) : capturedEffort;
-    return { model, effort };
+    const derivedEffort = cliToolId === 'antigravity' ? (deriveEffortFromModelId(model) ?? capturedEffort) : capturedEffort;
+    return { model, effort: (hooksEffort || null) ?? derivedEffort };
 }