@vibe-cafe/vibe-usage 0.12.0 → 0.13.0

package/README.md

@@ -62,9 +62,10 @@ npx @vibe-cafe/vibe-usage help --all   # Full help (plain `help` shows the short
 
 The versioned `quota` JSON contract is designed for local desktop clients. `discover` only checks ordinary app, config-directory, and executable presence signals: it does not open credentials or use the network. `fetch` invokes only products explicitly named with `--product`, and one provider failure does not prevent results for the others.
 
-- **Kimi Code** reads the official Kimi CLI OAuth file (`$KIMI_SHARE_DIR/credentials/kimi-code.json`, otherwise `~/.kimi/credentials/kimi-code.json`) and calls `https://api.kimi.com/coding/v1/usages`. When the short-lived access token is close to expiry, it uses Kimi's standard OAuth refresh flow and atomically rotates the official credential with owner-only permissions. Refreshes are serialized across Vibe Usage processes and re-check the file before writing so a concurrent Kimi CLI refresh wins safely.
+- **Kimi Code** reads the official OAuth file from `$KIMI_CODE_HOME/credentials/kimi-code.json` (otherwise `~/.kimi-code/credentials/kimi-code.json`) and falls back to the legacy `$KIMI_SHARE_DIR` / `~/.kimi` location — the first login that exists wins. It calls `https://api.kimi.com/coding/v1/usages` and supports both the current 2.x response and the legacy quota response. When the short-lived access token is close to expiry, it uses Kimi's standard OAuth refresh flow and atomically rotates the official credential with owner-only permissions. Refreshes are serialized across Vibe Usage processes and re-check the file before writing so a concurrent Kimi CLI refresh wins safely.
 - **ZCode / GLM Coding Plan** accepts only a caller-supplied regional key: `BIGMODEL_API_KEY` calls the domestic `https://open.bigmodel.cn/api/monitor/usage/quota/limit`, while the existing `Z_AI_API_KEY` keeps using `https://api.z.ai/api/monitor/usage/quota/limit`. If both are present, the explicitly named BigModel key wins. It does not read ZCode's private OAuth state.
 - **Grok** reads at most the final 2 MiB of the official CLI's ordinary `$GROK_HOME/logs/unified.jsonl` (default `~/.grok/logs/unified.jsonl`). It accepts only the structured `billing: fetched credits config` event and projects the current utilization, period bounds, subscription tier, and event timestamp. It performs no network request, reads no credentials, and never returns or retains other log fields.
+- **OpenCode Go** reads only the `opencode-go` integration key from OpenCode's own credential table (`~/.local/share/opencode/opencode.db`, read-only via the shared SQLite helper), falling back to the CLI's `auth.json` `opencode.key` for the pre-2.x layout that keeps its login there (`VIBE_USAGE_OPENCODE_DIRS` replaces discovery for fixtures/relocated data), and calls the official `https://opencode.ai/zen/go/v1/usage` endpoint with it. It reports the three windows OpenCode Go enforces (5-hour rolling, weekly, monthly) as normalized meters. A valid OpenCode key without an active Go subscription (HTTP 403) is a quiet "no data" rather than an error. The key is never written back, logged, or included in output; only a one-way hash of it scopes the disposable cache.
 - **Cursor** is detected independently but remains non-fetchable until an official or stable quota protocol is available. Quota monitoring does not read Cursor's login token/database, browser cookies, another app's Keychain, network traffic, or UI.
 
 Quota results are never uploaded or added to incremental sync state. Credential-backed providers may use the disposable cache at `~/.vibe-usage/quota-cache.json`; it contains normalized meters only, is scoped to a one-way hash of the active credential, rejects expired windows, and has a seven-day hard expiry. Grok's local-log result is not cached. No credential is stored in that cache, logs, or command output; the only credential write is Kimi's standard token rotation back to Kimi's own credential file.
@@ -85,7 +86,7 @@ Quota results are never uploaded or added to incremental sync state. Credential-
 | Cursor | `state.vscdb` (SQLite, reads `cursorAuth/accessToken`, fetches CSV from `cursor.com`); cloud data is stamped with a fixed `cursor-cloud` hostname so multi-machine setups don't double-count |
 | DimAgent | `$DIMCODE_HOME/dimcode.sqlite` (default `~/.dimcode/v2/dimcode.sqlite`); exact usage from `usage_ledger`, with forked ledger/history copies deduplicated |
 | Gemini CLI | `~/.gemini/tmp/<project_hash>/chats/session-*.jsonl` (current line-delimited format) and legacy `session-*.json`; recurses into nested subagent sessions |
-| OpenCode | `~/.local/share/opencode/opencode.db` (SQLite), with `storage/message/` as the legacy alternative; supports explicitly added data roots |
+| OpenCode | `~/.local/share/opencode/opencode.db` (SQLite) — both the legacy `message` table and the 2.x `session_message` projection are read, merged by message id — with `storage/message/` as the legacy alternative; cache writes are counted as 5m cache creation; supports explicitly added data roots |
 | OpenClaw | `~/.openclaw/agents/`, `~/.openclaw-<profile>/agents/` (profile deployments); cache-creation/cache-write tokens are included in input usage |
 | Oh My Pi | `~/.omp/agent/sessions/`, `~/.omp/profiles/*/agent/sessions/`, and `$XDG_DATA_HOME/omp/{sessions,profiles/*/sessions}`; recognizes OMP's `$PI_CODING_AGENT_DIR`, current v3 title slots and path/hashed session directories, deduplicates copied records, includes cache writes in input, and splits reasoning from OMP's inclusive output count |
 | pi | `~/.pi/agent/sessions/` or `$PI_CODING_AGENT_DIR/sessions/`, plus the session directory Pi itself was pointed at via `PI_CODING_AGENT_SESSION_DIR` or `sessionDir` in `~/.pi/agent/settings.json`, plus explicitly added `pi-coding-agent` roots for stores only reachable through `pi --session <file>` (fixture/relocation override: `VIBE_USAGE_PI_SESSION_DIRS`). Cache writes are included in input usage; reasoning is read from Pi's `usage.reasoning` (legacy `usage.reasoningTokens` still accepted) and split out of the inclusive output total |
@@ -95,7 +96,7 @@ Quota results are never uploaded or added to incremental sync state. Credential-
 | MiMoCode | `$MIMOCODE_HOME/data/mimocode.db`, `$XDG_DATA_HOME/mimocode/mimocode.db`, or `~/.local/share/mimocode/mimocode.db` (SQLite; exact input, output, reasoning, and cache-read tokens from assistant messages; honors `MIMOCODE_DB`; cache-write tokens are included in input usage) |
 | Amp | `~/.local/share/amp/threads/`; cache-creation tokens are included in input usage |
 | Droid | `~/.factory/sessions/` |
-| DeepSeek Harness | `$DSH_HOME/sessions/` (default `~/.dsh`, fixture/relocation override: `VIBE_USAGE_DSH_SESSIONS`). Reads V0–V3 logs, including `session.v3.jsonl.zstd` from DSH `0.1.5-alpha.2`, with multi-frame Zstandard support (Node ≥ 22.15 built-in, `zstd` CLI fallback) and plain JSONL support. Each session uses its highest `session[.vN].jsonl[.zstd]` generation once, so frozen pre-migration logs are not double-counted. Usage comes from `assistant/message`: cache writes join uncached input, cache reads remain separate, and reasoning is split out of inclusive output. Fork history uses V0/V1 `seedLength` or V2/V3's last `session/end-seed` tagged `inherited: true`, and is skipped only when the parent copy confirms it; missing parents retain the sole local history. Unknown versions warn and protect sync state. |
+| DeepSeek Harness | `$DSH_HOME/sessions/` (default `~/.dsh`, fixture/relocation override: `VIBE_USAGE_DSH_SESSIONS`). Reads V0–V4 logs, including `session.v4.jsonl.zstd` from DSH's V4 integration format, with multi-frame Zstandard support (Node ≥ 22.15 built-in, `zstd` CLI fallback) and plain JSONL support. Each session uses its highest `session[.vN].jsonl[.zstd]` generation once, so frozen pre-migration logs are not double-counted. Usage comes from `assistant/message`: cache writes join uncached input, cache reads remain separate, and reasoning is split out of inclusive output. Fork history uses V0/V1 `seedLength` or V2–V4's last `session/end-seed` tagged `inherited: true`, and is skipped only when the parent copy confirms it; missing parents retain the sole local history. Unknown versions warn and protect sync state. |
 | Hermes (CLI / Desktop) | `<home>/state.db` + `<home>/profiles/<name>/state.db` (SQLite, multi-profile). Home: `$HERMES_HOME`, otherwise `~/.hermes` on macOS/Linux or `%LOCALAPPDATA%\hermes` on Windows (falls back to an existing `~/.hermes` only when the Windows native root is absent). Cache writes join input; reasoning is separated from inclusive output. Usage is currently a cumulative session total attributed to session start: a session spanning several days does **not** yet provide an accurate daily breakdown. |
 | Kiro | Kiro CLI native event streams `~/.kiro/sessions/cli/*.jsonl` (estimated tokens from message text: input = prompt + tool results, output = reply + tool calls, reasoning = thinking, cacheRead = re-sent context; thinking-block signatures excluded). Falls back to `~/Library/Application Support/kiro-cli/data.sqlite3` / `~/.local/share/kiro-cli/data.sqlite3` + optional `~/.kiro_sessions/*.json` archives, then IDE `q-client.log` whole-credit deltas as `kiro-credits` (floored cumulative diff — the server stores token counts as bigint); legacy IDE `dev_data/devdata.sqlite` token telemetry is opt-in with `VIBE_USAGE_KIRO_LEGACY_TOKENS=1` |
 | Cline (CLI / SDK / Desktop app) | All variants write the same `~/.cline/data/sessions/*/*.messages.json` per-call metrics (the desktop app's manifest says `source: "desktop"`; its Electron userData holds only WebView caches), plus legacy `~/.cline/{,data/}state/taskHistory.json` and editor extension stores. Honors `CLINE_DIR`, `CLINE_DATA_DIR`, and `CLINE_SESSION_DATA_DIR`; copied history is deduplicated |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibe-cafe/vibe-usage",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Track your AI coding tool token usage and sync to vibecafe.ai",
   "type": "module",
   "scripts": {

package/src/daemon-service.js

@@ -114,19 +114,40 @@ function escapeXml(value) {
 
 // Variables that relocate a tool's on-disk store. The service runs from a
 // launchd/systemd unit that inherits nothing, so anything the parsers read for
-// discovery has to be captured into the unit at install time.
+// discovery has to be captured into the unit at install time. Keep this list in
+// sync with the store-locating variables the parsers and roots modules read
+// (`grep -rho 'process\.env\.[A-Z_]*' src/parsers src/*-roots.js`): a variable
+// missing here makes the background service sync a different store than the
+// foreground CLI (issue #112). Test-only overrides (`VIBE_USAGE_*`) and
+// accounting knobs are deliberately absent -- they do not relocate a store.
 const PRESERVED_SERVICE_ENV = [
+  'AMP_DATA_DIR',
   'CLINE_DIR',
   'CLINE_DATA_DIR',
   'CLINE_SESSION_DATA_DIR',
+  'CODEBUDDY_CONFIG_DIR',
+  'CODEX_HOME',
   'COLA_DATA_DIR',
+  'CRAFT_AGENT_DIR',
+  'CRAFTAGENT_DIR',
+  'CURSOR_CONFIG_DIR',
+  'DIMCODE_HOME',
+  'DSH_HOME',
+  'GROK_HOME',
   'HERMES_HOME',
+  'KIMI_CODE_HOME',
+  'KIRO_BASE_PATH',
+  'KIRO_CLI_DB_PATH',
+  'KIRO_CLI_SESSIONS_DIR',
+  'KIRO_SESSIONS_DIR',
+  'KIRO_USER_PATH',
   'MCODE_HOME',
   'MIMOCODE_HOME',
   'MIMOCODE_DB',
-  'XDG_DATA_HOME',
+  'PI_CONFIG_DIR',
   'PI_CODING_AGENT_DIR',
   'PI_CODING_AGENT_SESSION_DIR',
+  'XDG_DATA_HOME',
 ];
 
 function serviceEnvironment(claudeConfigDir, env) {

package/src/parsers/dsh.js

@@ -7,13 +7,18 @@ import { aggregateToBuckets, extractSessions } from './aggregate.js';
 
 const SOURCE = 'dsh';
 
-// Verified against deepseek-ai/deepseek-harness tag dsh-v0.1.5-alpha.2:
+// Verified against deepseek-ai/deepseek-harness, released formats V0-V4:
 // packages/session/session-format/src/filename.ts, session-format-v0-to-v1,
-// session-format-v1-to-v2, session-format-v2-to-v3, and core/session/src/types.ts.
-// V0/V1 use header.seedLength; V2/V3 use a tagged inherited end-seed marker.
+// session-format-v1-to-v2, session-format-v2-to-v3, core/session/src/types.ts,
+// and docs/persistence-changes/2026-09-16-session-format-v4.md.
+// V0/V1 use header.seedLength; V2-V4 use a tagged inherited end-seed marker.
+// V4 (SESSION_FORMAT_VERSION = 4, commit 669b724a78) keeps the filename, header
+// fields, assistant usage block, and inherited cut; it lifts user-role tool
+// results into tool-role messages, adds forked to turn/end.reason, and adds
+// developer/message, none of which carry billable usage.
 // Re-check the format before accepting another version; never silently read a
 // frozen predecessor when a newer generation is present.
-const MAX_SESSION_FORMAT_VERSION = 3;
+const MAX_SESSION_FORMAT_VERSION = 4;
 const SESSION_FILENAME = /^session(?:\.v([1-9][0-9]*))?\.jsonl(\.zstd)?$/;
 
 // Safety cap for a single session log. DSH stores many small zstd frames per
@@ -200,7 +205,7 @@ function isUserMessageRecord(rec) {
  *   {"type":"user/message"|"assistant/message","time":...,"data":{...}}
  *
  * V0/V1 use header.seedLength. Their untagged end-seed markers can appear
- * after real history and must never be treated as a replay boundary. V2/V3
+ * after real history and must never be treated as a replay boundary. V2-V4
  * instead require isSeeded and use the LAST end-seed with data.inherited=true.
  * Only a proven inherited prefix also present in the parent is skipped.
  *

package/src/parsers/opencode.js

@@ -4,18 +4,57 @@ import { aggregateToBuckets, extractSessions } from './aggregate.js';
 import { queryDbJson, sqliteUnavailableError, isSqliteUnavailableError } from './sqlite.js';
 import { getOpenCodeStores } from '../opencode-roots.js';
 
-function readSqlite(path) {
-  // Select only accounting/timing metadata, never message text or tool inputs.
-  // Keep the existing top-level model/project precedence for old uploads.
-  const query = `SELECT id, session_id AS sessionID,
+// Select only accounting/timing metadata, never message text or tool inputs.
+// Keep the existing top-level model/project precedence for old uploads.
+const V1_QUERY = `SELECT id, session_id AS sessionID,
     json_extract(data, '$.role') AS role,
     json_extract(data, '$.time.created') AS created,
     coalesce(json_extract(data, '$.modelID'), json_extract(data, '$.model.modelID')) AS modelID,
     json_extract(data, '$.tokens') AS tokens,
     json_extract(data, '$.path.root') AS rootPath
     FROM message ORDER BY id`;
-  try { return queryDbJson(path, query); }
-  catch (err) {
+
+// OpenCode 2.x stores the same accounting in the event-sourced projection
+// `session_message`: the row's `type` is the role, `data.model.id` the model,
+// `data.tokens` the counters. Message data carries no `path`, so the project
+// comes from the session row's `directory`; the session table is `session_v2`
+// in 2.x and `session` before that (both names in the wild, issue #114). Only
+// column/JSON expressions are selected -- never message text, tool payloads,
+// or costs.
+function v2Query(sessionTable) {
+  return `SELECT m.id AS id, m.session_id AS sessionID,
+    m.type AS role,
+    coalesce(json_extract(m.data, '$.time.created'), m.time_created) AS created,
+    coalesce(json_extract(m.data, '$.model.id'), json_extract(m.data, '$.modelID')) AS modelID,
+    json_extract(m.data, '$.tokens') AS tokens,
+    s.directory AS directory
+    FROM session_message m
+    ${sessionTable ? `LEFT JOIN ${sessionTable} s ON s.id = m.session_id` : ''}
+    WHERE m.type IN ('user', 'assistant')
+    ORDER BY m.id`;
+}
+
+function readSqlite(path) {
+  try {
+    const tables = new Set(queryDbJson(path,
+      `SELECT name FROM sqlite_master WHERE type = 'table'
+       AND name IN ('message', 'session_message', 'session', 'session_v2')`)
+      .map(row => row.name));
+    if (!tables.has('message') && !tables.has('session_message')) {
+      throw new Error(`不认识的表结构（没有 message / session_message 表）: ${path}`);
+    }
+    // Read both shapes when a migrated store keeps both: copies are merged by
+    // (session, message id), and the legacy row is seen first so an equal copy
+    // never renames a project that earlier uploads already used.
+    const rows = [];
+    if (tables.has('message')) rows.push(...queryDbJson(path, V1_QUERY));
+    if (tables.has('session_message')) {
+      const sessionTable = tables.has('session_v2') ? 'session_v2'
+        : (tables.has('session') ? 'session' : null);
+      rows.push(...queryDbJson(path, v2Query(sessionTable)));
+    }
+    return rows;
+  } catch (err) {
     if (isSqliteUnavailableError(err)) throw sqliteUnavailableError('OpenCode');
     throw err;
   }
@@ -71,14 +110,24 @@ export async function parse({ extraRoots = [] } = {}) {
   for (const row of records.values()) {
     // Keep the existing project derivation and token semantics. Additional roots
     // must not rename previously uploaded projects/models or alter their counts.
-    const project = row.rootPath ? basename(row.rootPath) : 'unknown';
+    // V2 message rows carry no `path`, so they fall back to the session
+    // directory; they come from a store the parser could not read before, so
+    // nothing previously uploaded is relabelled by that fallback.
+    const project = row.rootPath ? basename(row.rootPath)
+      : (row.directory ? basename(row.directory) : 'unknown');
     const base = { source: 'opencode', project, timestamp: row.timestamp };
     events.push({ ...base, sessionId: row.sessionId, role: row.role === 'user' ? 'user' : 'assistant' });
     const tokens = row.tokens;
     if (!row.modelID || !tokens || (!tokens.input && !tokens.output)) continue;
     entries.push({ ...base, model: row.modelID,
       inputTokens: tokens.input || 0, outputTokens: tokens.output || 0,
-      cachedInputTokens: tokens.cache?.read || 0, reasoningOutputTokens: tokens.reasoning || 0 });
+      cachedInputTokens: tokens.cache?.read || 0, reasoningOutputTokens: tokens.reasoning || 0,
+      // The store writes one cache-write total with no per-TTL breakdown and no
+      // separate `tokens.total` column to reconcile against, so it goes to the
+      // cheaper 5m cache-creation bucket -- the same rule as CodeArts Agent,
+      // which reads this exact layout. Dropping it (the behaviour until
+      // 2026-09-26) under-billed every Claude/Anthropic run through OpenCode.
+      cacheCreation5mTokens: tokens.cache?.write || 0 });
   }
   return { buckets: aggregateToBuckets(entries), sessions: extractSessions(events) };
 }

package/src/quotas/providers/kimi-code.js

@@ -15,7 +15,7 @@ import {
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { attachCacheScope } from '../cache.js';
-import { quotaResult } from '../schema.js';
+import { canonicalizeMeters, quotaResult } from '../schema.js';
 
 const PRODUCT_ID = 'kimi-code';
 const DEFAULT_USAGE_URL = 'https://api.kimi.com/coding/v1/usages';
@@ -110,6 +110,29 @@ export function parseKimiUsage(payload, now = new Date()) {
     throw new Error('Kimi usage response is not an object');
   }
   const meters = [];
+  if (payload.usages && typeof payload.usages === 'object' && !Array.isArray(payload.usages)) {
+    const currentMeters = [
+      ['limit_5h', '5h', 5 * 3600],
+      ['limit_7d', '7d', 7 * 86400],
+      ['limit_month_total', 'Monthly', null],
+      ['limit_month_code', 'Monthly Code', null],
+    ];
+    for (const [key, label, windowSeconds] of currentMeters) {
+      const entry = payload.usages[key];
+      if (!entry || typeof entry !== 'object' || Array.isArray(entry)) continue;
+      const ratio = number(entry.used_ratio ?? entry.usedRatio);
+      if (ratio === null) continue;
+      const meter = {
+        id: key.replaceAll('_', '-'),
+        label,
+        utilization: Math.max(0, Math.min(100, ratio * 100)),
+      };
+      const resetsAt = resetDate(entry, now);
+      if (resetsAt) meter.resetsAt = resetsAt.toISOString();
+      if (windowSeconds) meter.windowSeconds = windowSeconds;
+      meters.push(meter);
+    }
+  }
   if (payload.usage && typeof payload.usage === 'object' && !Array.isArray(payload.usage)) {
     const summary = meterFrom(payload.usage, payload.usage, 0, 'Weekly', now);
     if (summary) meters.push(summary);
@@ -126,7 +149,7 @@ export function parseKimiUsage(payload, now = new Date()) {
     }
   }
   const seen = new Set();
-  return meters.filter(meter => {
+  return canonicalizeMeters(meters).filter(meter => {
     const key = `${meter.label}\0${meter.windowSeconds || ''}`;
     if (seen.has(key)) return false;
     seen.add(key);
@@ -134,9 +157,33 @@ export function parseKimiUsage(payload, now = new Date()) {
   });
 }
 
+// Kimi Code has two credential locations in the wild: the current CLI (2.x)
+// writes `$KIMI_CODE_HOME/credentials/kimi-code.json`, defaulting to
+// `~/.kimi-code` -- the same home the session parser already resolves -- while
+// kimi-cli (1.x) keeps `$KIMI_SHARE_DIR/credentials/kimi-code.json`, defaulting
+// to `~/.kimi`. Reading only the legacy path reported `missing_credentials` for
+// every 2.x user whose login sits in the new home (issue #112), while their
+// usage parsed fine, so the quota card contradicted the token tables.
+export function kimiCredentialPaths(environment = process.env, home = homedir()) {
+  const codeHome = environment.KIMI_CODE_HOME?.trim() || join(home, '.kimi-code');
+  const legacyHome = environment.KIMI_SHARE_DIR?.trim() || join(home, '.kimi');
+  return [...new Set([codeHome, legacyHome]
+    .map(directory => join(directory, 'credentials', 'kimi-code.json')))];
+}
+
+// The file to read and, on refresh, to rotate atomically: the first existing
+// login, current home before legacy, so a stale `KIMI_SHARE_DIR` cannot shadow
+// the CLI the user actually runs. With no login anywhere the current CLI's path
+// is returned, so `missing_credentials` (and any rotation after a later login)
+// names the file the installed CLI writes.
 export function kimiCredentialPath(environment = process.env, home = homedir()) {
-  const shareDirectory = environment.KIMI_SHARE_DIR?.trim() || join(home, '.kimi');
-  return join(shareDirectory, 'credentials', 'kimi-code.json');
+  const paths = kimiCredentialPaths(environment, home);
+  for (const path of paths) {
+    try {
+      if (statSync(path).isFile()) return path;
+    } catch {}
+  }
+  return paths[0];
 }
 
 function readCredentials(path) {

package/src/quotas/providers/opencode-go.js

@@ -0,0 +1,222 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { delimiter, join } from 'node:path';
+import { attachCacheScope } from '../cache.js';
+import { quotaResult } from '../schema.js';
+import { isSqliteUnavailableError, queryDbJson, sqliteUnavailableError } from '../../parsers/sqlite.js';
+
+const PRODUCT_ID = 'opencode-go';
+const INTEGRATION_ID = 'opencode-go';
+const DEFAULT_USAGE_URL = 'https://opencode.ai/zen/go/v1/usage';
+
+// The endpoint reports the three windows OpenCode Go enforces (rolling /
+// weekly / monthly). It does not return the rolling window length, but the
+// official console labels the rolling window "5 hours", so the meter reuses
+// that window name; weekly/monthly are calendar windows whose reset instant
+// travels with the response.
+const METER_ORDER = [
+  ['rolling', '5h'],
+  ['weekly', 'Weekly'],
+  ['monthly', 'Monthly'],
+];
+
+/** Data roots scanned for the OpenCode credential store, in order. */
+export function openCodeDataRoots(environment = process.env, home = homedir()) {
+  const override = environment.VIBE_USAGE_OPENCODE_DIRS?.trim();
+  if (override) {
+    return override.split(delimiter).map(value => value.trim()).filter(Boolean);
+  }
+  return [join(home, '.local', 'share', 'opencode')];
+}
+
+export function openCodeDbPath(root) {
+  return join(root, 'opencode.db');
+}
+
+function date(value) {
+  if (typeof value !== 'string' || !value.trim()) return null;
+  const parsed = new Date(value);
+  return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+
+/**
+ * Reads only the `opencode-go` integration key from OpenCode's credential
+ * table. The value is the client's own JSON blob (`{ type: 'key', key }`);
+ * nothing else in the row or database is selected, logged, cached, or
+ * uploaded.
+ */
+function readCredentialTable(root) {
+  const dbPath = openCodeDbPath(root);
+  if (!existsSync(dbPath)) return { status: 'missing' };
+  try {
+    const rows = queryDbJson(dbPath, `SELECT value FROM credential
+      WHERE integration_id = '${INTEGRATION_ID}'
+      ORDER BY coalesce(active, 1) DESC, time_updated DESC
+      LIMIT 1`);
+    const raw = rows[0]?.value;
+    if (typeof raw !== 'string' || !raw.trim()) return { status: 'missing' };
+    let key = '';
+    try {
+      const parsed = JSON.parse(raw);
+      key = typeof parsed?.key === 'string' ? parsed.key.trim() : '';
+    } catch {
+      key = '';
+    }
+    return key ? { status: 'ok', key } : { status: 'missing' };
+  } catch (error) {
+    if (isSqliteUnavailableError(error)) return { status: 'unavailable' };
+    // An older/newer schema without the credential table simply has no login.
+    if (/no such table|no such column/i.test(error?.message || '')) return { status: 'missing' };
+    return { status: 'error' };
+  }
+}
+
+/**
+ * Fallback for the pre-2.x layout, which keeps the same key as plain JSON in
+ * `auth.json` (`{"opencode": {"type": "api", "key": "sk-..."}}`). Only that one
+ * entry is read; sibling provider credentials in the file are never inspected,
+ * and the key is returned to the caller without ever being logged or cached.
+ * The credential table stays authoritative when it has a Go row — it is the
+ * Go-specific record, while `auth.json` also holds non-Go keys.
+ */
+function readAuthFile(root) {
+  let parsed = null;
+  try {
+    parsed = JSON.parse(readFileSync(join(root, 'auth.json'), 'utf8'));
+  } catch {
+    return { status: 'missing' };
+  }
+  const key = parsed?.opencode?.key;
+  const trimmed = typeof key === 'string' ? key.trim() : '';
+  return trimmed ? { status: 'ok', key: trimmed } : { status: 'missing' };
+}
+
+/**
+ * The Go key for one data root, or a failure to report. The credential table
+ * wins; `auth.json` covers stores that never migrated. A concrete table read
+ * failure is preserved only when the fallback has no key either, so an
+ * unreadable database cannot hide a perfectly good login.
+ */
+function readCredential(root) {
+  const table = readCredentialTable(root);
+  if (table.status === 'ok') return table;
+  const authFile = readAuthFile(root);
+  if (authFile.status === 'ok') return authFile;
+  return table;
+}
+
+export function parseOpenCodeGoUsage(payload) {
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+    throw new Error('OpenCode usage response is not an object');
+  }
+  const usage = payload.usage;
+  const meters = [];
+  for (const [id, label] of METER_ORDER) {
+    const item = usage?.[id];
+    if (!item || typeof item !== 'object' || Array.isArray(item)) continue;
+    const percent = Number(item.percent);
+    if (!Number.isFinite(percent)) continue;
+    const meter = { id, label, utilization: Math.max(0, Math.min(100, percent)) };
+    const resetsAt = date(item.resetsAt);
+    if (resetsAt) meter.resetsAt = resetsAt.toISOString();
+    meters.push(meter);
+  }
+  return meters;
+}
+
+export async function fetchOpenCodeGoQuota({
+  environment = process.env,
+  home = homedir(),
+  fetchImpl = globalThis.fetch,
+  usageURL = DEFAULT_USAGE_URL,
+  now = new Date(),
+  timeoutMs = 10_000,
+} = {}) {
+  let credential = { status: 'missing' };
+  for (const root of openCodeDataRoots(environment, home)) {
+    const found = readCredential(root);
+    if (found.status === 'ok') {
+      credential = found;
+      break;
+    }
+    // Keep the first concrete read failure; a missing database just means the
+    // next configured root may hold the login.
+    if (found.status !== 'missing' && credential.status === 'missing') credential = found;
+  }
+  if (credential.status === 'unavailable') {
+    return quotaResult({
+      id: PRODUCT_ID,
+      status: 'retryable_error',
+      message: sqliteUnavailableError('OpenCode Go').message,
+      fetchedAt: now,
+    });
+  }
+  if (credential.status === 'error') {
+    return quotaResult({
+      id: PRODUCT_ID,
+      status: 'retryable_error',
+      message: 'OpenCode credential store could not be read',
+      fetchedAt: now,
+    });
+  }
+  if (credential.status !== 'ok') {
+    return quotaResult({
+      id: PRODUCT_ID,
+      status: 'missing_credentials',
+      message: 'OpenCode Go is not logged in',
+      fetchedAt: now,
+    });
+  }
+
+  const token = credential.key;
+  try {
+    const response = await fetchImpl(usageURL, {
+      method: 'GET',
+      headers: { Authorization: `Bearer ${token}`, Accept: 'application/json' },
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+    if (response.status === 401) {
+      return attachCacheScope(quotaResult({
+        id: PRODUCT_ID,
+        status: 'unauthorized',
+        message: 'OpenCode Go rejected the saved API key',
+        fetchedAt: now,
+      }), token);
+    }
+    if (response.status === 403) {
+      // A valid OpenCode key without an active Go subscription.
+      return attachCacheScope(quotaResult({
+        id: PRODUCT_ID,
+        status: 'no_data',
+        message: 'OpenCode Go subscription is not active',
+        fetchedAt: now,
+      }), token);
+    }
+    if (!response.ok) {
+      return attachCacheScope(quotaResult({
+        id: PRODUCT_ID,
+        status: 'retryable_error',
+        message: `OpenCode usage API returned HTTP ${response.status}`,
+        fetchedAt: now,
+      }), token);
+    }
+    const meters = parseOpenCodeGoUsage(await response.json());
+    return attachCacheScope(quotaResult({
+      id: PRODUCT_ID,
+      status: meters.length ? 'ok' : 'no_data',
+      meters,
+      message: meters.length ? undefined : 'OpenCode usage API returned no window',
+      fetchedAt: now,
+      dataAsOf: now,
+    }), token);
+  } catch (error) {
+    return attachCacheScope(quotaResult({
+      id: PRODUCT_ID,
+      status: 'retryable_error',
+      message: error?.name === 'TimeoutError'
+        ? 'OpenCode usage request timed out'
+        : 'OpenCode usage request failed',
+      fetchedAt: now,
+    }), token);
+  }
+}

package/src/quotas/registry.js

@@ -4,6 +4,7 @@ import { delimiter, join } from 'node:path';
 import { loadCachedQuota, saveCachedQuota } from './cache.js';
 import { fetchGrokQuota } from './providers/grok.js';
 import { fetchKimiCodeQuota } from './providers/kimi-code.js';
+import { fetchOpenCodeGoQuota } from './providers/opencode-go.js';
 import { fetchZaiQuota } from './providers/zai.js';
 import { FETCHABLE_QUOTA_PRODUCT_IDS, quotaEnvelope, quotaResult } from './schema.js';
 
@@ -11,6 +12,7 @@ const providers = new Map([
   ['kimi-code', fetchKimiCodeQuota],
   ['zcode', fetchZaiQuota],
   ['grok', fetchGrokQuota],
+  ['opencode-go', fetchOpenCodeGoQuota],
 ]);
 
 function executableExists(name, environment, platform) {
@@ -73,6 +75,12 @@ export function discoverQuotaProducts({
       detected: existsAny([grokHome]) || executableExists('grok', environment, platform),
       fetchable: true,
     },
+    {
+      id: 'opencode-go',
+      detected: existsAny([join(home, '.local', 'share', 'opencode')])
+        || executableExists('opencode', environment, platform),
+      fetchable: true,
+    },
     {
       id: 'cursor',
       detected: existsAny([join(home, '.cursor'),

package/src/quotas/schema.js

@@ -4,6 +4,7 @@ export const QUOTA_PRODUCT_IDS = Object.freeze([
   'kimi-code',
   'zcode',
   'grok',
+  'opencode-go',
   'cursor',
 ]);
 
@@ -11,6 +12,7 @@ export const FETCHABLE_QUOTA_PRODUCT_IDS = Object.freeze([
   'kimi-code',
   'zcode',
   'grok',
+  'opencode-go',
 ]);
 
 const FETCH_STATUSES = new Set([
@@ -59,6 +61,65 @@ export function normalizeMeter(raw, index = 0) {
   return meter;
 }
 
+const PERIOD_LABELS = new Map([
+  ['daily', { label: '1d', seconds: 24 * 60 * 60, exact: true }],
+  ['day', { label: '1d', seconds: 24 * 60 * 60, exact: true }],
+  ['weekly', { label: '7d', seconds: 7 * 24 * 60 * 60, exact: true }],
+  ['week', { label: '7d', seconds: 7 * 24 * 60 * 60, exact: true }],
+  ['monthly', { label: 'Month', seconds: 30 * 24 * 60 * 60, exact: false }],
+  ['month', { label: 'Month', seconds: 30 * 24 * 60 * 60, exact: false }],
+]);
+
+function periodPresentation(meter) {
+  const compact = meter.label.trim().toLowerCase().replace(/\s+/g, '');
+  const alias = PERIOD_LABELS.get(compact);
+  if (alias) {
+    return {
+      label: alias.label,
+      seconds: meter.windowSeconds || alias.seconds,
+      inferredWindowSeconds: alias.exact ? alias.seconds : undefined,
+    };
+  }
+
+  const match = /^(\d+(?:\.\d+)?)(m|h|d|w)$/.exec(compact);
+  if (!match) return null;
+  const multipliers = { m: 60, h: 3600, d: 86400, w: 7 * 86400 };
+  const seconds = meter.windowSeconds || Number(match[1]) * multipliers[match[2]];
+  const label = compact === '1w' ? '7d' : compact;
+  return { label, seconds, inferredWindowSeconds: seconds };
+}
+
+/**
+ * Keep the compact desktop cards predictable across providers: generic time
+ * windows come first from shortest to longest, followed by model-specific and
+ * feature meters in their provider-defined order. The original index is the
+ * final comparison key so the sort remains deterministic on every JS runtime.
+ */
+export function canonicalizeMeters(rawMeters) {
+  return rawMeters
+    .map((raw, index) => {
+      const meter = normalizeMeter(raw, index);
+      const period = periodPresentation(meter);
+      if (period) {
+        meter.label = period.label;
+        if (!meter.windowSeconds && period.inferredWindowSeconds) {
+          meter.windowSeconds = period.inferredWindowSeconds;
+        }
+      }
+      return { meter, periodSeconds: period?.seconds, index };
+    })
+    .sort((left, right) => {
+      const leftIsPeriod = left.periodSeconds !== undefined;
+      const rightIsPeriod = right.periodSeconds !== undefined;
+      if (leftIsPeriod !== rightIsPeriod) return leftIsPeriod ? -1 : 1;
+      if (leftIsPeriod && left.periodSeconds !== right.periodSeconds) {
+        return left.periodSeconds - right.periodSeconds;
+      }
+      return left.index - right.index;
+    })
+    .map(item => item.meter);
+}
+
 export function quotaResult({
   id,
   status,
@@ -78,7 +139,7 @@ export function quotaResult({
   const result = {
     id,
     status,
-    meters: meters.map(normalizeMeter),
+    meters: canonicalizeMeters(meters),
     fetchedAt: new Date(fetchedAt).toISOString(),
     source,
   };