opencode-usage-coach 0.2.3 → 0.2.5

package/README.md

@@ -1,16 +1,17 @@
 # opencode-usage-coach
 
 A closed-loop usage coach and harness for [OpenCode](https://opencode.ai). Built for
-flat-rate coding plans (e.g. z.ai / GLM) where USD cost is meaningless, so it tracks
+flat-rate / quota-metered coding plans where USD cost is meaningless, so it tracks
 **quota windows (5h / weekly / monthly)** and turns them into coaching + loop control.
+Provider-agnostic — configure via `harness.config.json`.
 
 Existing plugins only *display* usage. This one **senses quota → coaches → stops/advances
-the loop** — and ships a harness agent mode + a deterministic orchestrator.
+the loop** — and ships a harness agent mode.
 
 ## What it does
 
 **Always-on guardian (plugin):**
-- Senses z.ai quota windows via the `codexbar` CLI.
+- Senses provider quota windows via the `codexbar` CLI (config-driven — any provider codexbar knows).
 - On STOP threshold: blocks tool calls (`tool.execute.before` throws) → the agent self-stops.
 - Injects coaching (how to use right now) into the system prompt (double defense).
 - Surfaces a sidebar panel: per-provider quota meters + harness task states + coaching.
@@ -21,12 +22,15 @@ the loop** — and ships a harness agent mode + a deterministic orchestrator.
   unclear → clarify; substantive → generate→grade→revise→advance.
 - Multi-model via plugin tools `generate`/`grade`: run the configured generator/grader model
   (from `harness.config.json`) in a new session on the same server — no second terminal.
-  e.g. GLM generation + free mimo grading in one opencode session.
 - Reports progress via `task_update` → the sidebar panel shows live task states.
+- **Triggering the harness:** the agent auto-triages — trivial work is done directly,
+  substantive multi-step work enters the generate→grade loop. For reliable triggering,
+  explicitly ask "run this through the harness" or "use the harness for this". The harness
+  tools are only available when the harness agent mode is active (see Install).
 
 ## Requirements
-- opencode (tested on 1.17.13) with a z.ai coding-plan provider configured.
-- `codexbar` CLI with the z.ai key wired (`codexbar config set-api-key --provider zai --stdin`).
+- opencode (tested on 1.17.13) with a quota-metered provider configured.
+- `codexbar` CLI with your provider key wired (e.g. `codexbar config set-api-key --provider zai --stdin`).
 
 ## Install (from npm)
 ```jsonc
@@ -69,29 +73,29 @@ This plugin has **four config surfaces**. Only the first two are required to run
 
 ### 2. codexbar (quota data source)
 ```bash
-printf '%s' "$Z_AI_API_KEY" | codexbar config set-api-key --provider zai --stdin
+printf '%s' "$YOUR_PROVIDER_API_KEY" | codexbar config set-api-key --provider <id> --stdin
 ```
 
 ### 3. Harness config — `harness.config.json` (role → model) ★ the main one
-Place in the **work directory** beside `tasks.txt`/`rubric.md`. Each role runs on its model,
-so per-model quota is tracked (works for local LLMs — they show 0%).
+Place in the **work directory**. Each role runs on its model, so per-model quota is tracked
+(works for local LLMs — they show 0%).
 ```jsonc
 {
-  "generator":     "zai-coding-plan/glm-5.1",   // model that produces the work
-  "grader":        "ollama/llama3",              // model that grades it
-  "taskTimeoutMs": 1800000,                       // per-task timeout (on exceed: auto-split)
-  "maxRevisions":  2                              // revise attempts before giving up
+  "generator":     "opencode/deepseek-v4-flash-free",  // model that produces the work
+  "grader":        "opencode/mimo-v2.5-free",           // model that grades it
+  "provider":      "",                                   // codexbar quota provider ("" = default)
+  "lighterModel":  ""                                    // suggested when throttling
 }
 ```
 | Field | Default | Notes |
 |---|---|---|
-| `generator` | `UC_MODEL` | any `provider/model` opencode knows |
-| `grader` | `UC_MODEL` | can differ from generator (multi-model) |
-| `taskTimeoutMs` | `1800000` (30m) | exceed → task split into subtasks |
-| `maxRevisions` | `2` | FAIL → revise → re-grade, up to N times |
+| `generator` | **required** | any `provider/model` opencode knows |
+| `grader` | falls back to `generator` | can differ (multi-model) |
+| `provider` | `""` (codexbar default) | which provider's quota the guardian watches |
+| `lighterModel` | `""` | shown in throttle advice; env `UC_LIGHTER_MODEL` overrides |
 
-Missing roles fall back to `UC_MODEL`. Provider for quota is derived from the model id
-(`zai-coding-plan/...` → `zai`, `ollama/...` → `ollama`).
+`generator` is **required** — the tools return a clear error if missing. Copy
+`harness.config.example.json` to get started (both example models are free → never gated).
 
 ### 4. Env vars (thresholds / tuning)
 | Var | Default | Meaning |
@@ -101,12 +105,9 @@ Missing roles fall back to `UC_MODEL`. Provider for quota is derived from the mo
 | `UC_STOP_WEEKLY` | 95 | weekly STOP % |
 | `UC_THROTTLE_WEEKLY` | 85 | weekly throttle % |
 | `UC_STOP_MONTHLY` | 98 | monthly STOP % |
-| `UC_LIGHTER_MODEL` | glm-4.5-air | suggested model when throttling |
-| `UC_PROVIDER` | zai | codexbar provider for the guardian |
+| `UC_LIGHTER_MODEL` | (config `lighterModel`) | suggested model when throttling |
+| `UC_PROVIDER` | (config `provider`) | codexbar provider for the guardian |
 | `UC_TTL_MS` | 60000 | quota cache TTL (ms) |
-| `UC_MODEL` | zai-coding-plan/glm-5.1 | harness fallback model |
-| `UC_TASK_TIMEOUT_MS` | 1800000 | harness per-task timeout (overridden by config) |
-| `UC_MAX_REVISIONS` | 2 | harness revise attempts (overridden by config) |
 | `UC_DEBUG` | 0 | set to `1` for a diagnostic log at `~/.cache/opencode-usage-coach/coach.log` |
 
 ## Architecture
@@ -114,13 +115,58 @@ Missing roles fall back to `UC_MODEL`. Provider for quota is derived from the mo
 - **TUI module** (`src/tui.tsx`) — SolidJS, reads a state file, renders into `sidebar_footer`/`home_footer`. Loaded via `tui.json`. Bundled with `tsup` + `esbuild-plugin-solid`, solid kept **external** (resolves to opencode's bundle — avoids the duplicate-instance crash). Exports `{ tui }` (a bare function is misread as a server plugin).
 - server↔TUI communicate via a state file (`~/.cache/opencode-usage-coach/*.json`) — they are separate processes.
 
-Key lessons (see `PLAN.md`): never install `solid-js` in the config dir (conflicts with
+**Key lessons (hard-won):** never install `solid-js` in the config dir (conflicts with
 opencode's bundled solid); TUI plugins must be compiled + loaded via `tui.json` file path;
 `codexbar` must be called via `spawn` (the `$` BunShell leaks output to the TUI).
 
+## Troubleshooting
+
+Recurring issues and fixes — mostly learned the hard way during development.
+
+### TUI panel missing or harness not shown
+- **Check `tui.json` points at the `dist/tui.js` file path** — not the `plugins/` directory.
+  ```jsonc
+  // ~/.config/opencode/tui.json
+  { "$schema": "https://opencode.ai/tui.json", "plugin": ["/abs/path/dist/tui.js"] }
+  ```
+- **Do NOT install `solid-js` in the config dir** — conflicts with opencode's bundled solid, causes a crash. Keep it peer + external only.
+- **Export must be `{ tui }`** (an object) — a bare function is misread as a server plugin.
+- **Color prop is `fg`** (not `foreground`): `style={{ fg: theme.current.success }}`.
+- **Call `codexbar` via `spawn`** — the `$` BunShell leaks command output into the TUI.
+- **Harness not visible?** The TUI scans session subdirectories for the most recent `active:true` harness. A finished harness (`active:false`) is hidden.
+
+### LLM model selection (generate/grade)
+- **`generator` is required in `harness.config.json`** — the tools return a clear error if missing (the old z.ai fallback was removed in v0.2.4).
+- Format: `"provider/model"` (e.g. `"opencode/deepseek-v4-flash-free"`, `"opencode/mimo-v2.5-free"` — see `harness.config.example.json`).
+- **Config precedence**: workdir `harness.config.json` > global `~/.config/opencode-usage-coach/harness.config.json`.
+- Omitting `grader` falls back to `generator`. If neither is set, the grade tool returns FAIL + guidance.
+- `provider` (quota source) and `lighterModel` (suggested on throttle) are also configurable in the same file.
+
+### Parallel harness execution (generate_batch)
+- **Only INDEPENDENT tasks should be batched** — dependent tasks (B needs A) require sequential `generate` calls.
+- `generate_batch` runs each task in a separate sub-session on the same server (shared model config).
+- runModel polls the sub-session until `idle`/`completed` (max 10 min). Trace with `UC_DEBUG=1`:
+  ```
+  runModel(<generator>): session xxx created, prompt 142 chars
+  runModel(<generator>): poll 3s status="running"
+  runModel(<generator>): done 48s, 1203 chars
+  ```
+- `(no output)` means the sub-session returned no text. Check `~/.cache/opencode-usage-coach/coach.log` for the runModel trace (requires `UC_DEBUG=1`).
+- **Note**: runModel only terminates on explicit `idle`/`completed` status. An earlier bug broke on `!status` (undefined) immediately — fixed.
+
+### Multi-session (per-session state isolation)
+- Each opencode session has a unique sessionID; harness state is isolated per-session:
+  ```
+  ~/.cache/opencode-usage-coach/projects/<dir-hash>/<sessionID>/harness.json
+  ```
+- Different working directories get separate project state (keyed by path hash).
+- The TUI auto-discovers the most recent `active:true` harness — switching sessions shows that session's harness.
+- Harness completion sets `active:false` → hidden from the TUI.
+- Override the state path with `UC_STATE_DIR` (forces global state).
+
 ## Status
-- ✅ M0–M2 quota guardian + TUI panel (per-provider coach view, colors, collapsible Alt+H)
-- ✅ M3 harness: agent mode (triage) with generate/grade model-specific tools (1 terminal, multi-model)
-- ✅ M4 npm packaging (`opencode plugin install opencode-usage-coach`)
+- ✅ Quota guardian + TUI panel (per-provider coach view, colors, collapsible Alt+H)
+- ✅ Harness: agent mode (triage) with generate/grade model-specific tools (1 terminal, multi-model)
+- ✅ npm packaging (`opencode plugin install opencode-usage-coach`)
 
 License: MIT.

package/agents/usage-coach-harness.md

@@ -34,20 +34,22 @@ Default to the loop only when it genuinely adds value. Do not over-engineer smal
 ## Harness loop (only for substantive work)
 The user's message is the task source. If it has multiple distinct parts, decompose into discrete tasks (N); if it is one unit, N = 1.
 
-**Multi-model, 1 terminal:** the work runs via the plugin tools `generate` and `grade`, which use the configured models (generator/grader from harness.config.json) on the same server — so you get e.g. GLM generation + free mimo grading without a second terminal. Do NOT use the `task` tool for harness work; use `generate`/`grade`.
+**Multi-model, 1 terminal:** the work runs via the plugin tools `generate` and `grade`, which use the configured models (generator/grader from harness.config.json) on the same server — so you get e.g. a paid generator + a free grader without a second terminal. Do NOT use the `task` tool for harness work; use `generate`/`grade`.
 
-**Independent tasks → parallel:** if the decomposed tasks are INDEPENDENT, call multiple `generate` tools in the same turn (parallel sub-sessions). Cap by quota coaching (big-OK → 3-4; throttle → 1-2; STOP → none). DEPENDENT tasks (B needs A) → sequential.
+**Parallel independent tasks:** if the decomposed tasks are INDEPENDENT, prefer `generate_batch` (one call, all results at once) over multiple sequential `generate` calls. Cap by quota coaching (big-OK → 3-4; throttle → 1-2; STOP → none). DEPENDENT tasks (B needs A) → sequential `generate` calls.
 
 1. Call `harness_start(name, N)` to register the run on the panel.
 2. For each task i (1..N):
    a. `task_update(i, title, "generating")`.
-   b. **Generate** — call `generate({ prompt: "Task: {title}. Perform it for real in the current directory (write/edit files)." })`. The generator model does the work and returns a summary.
-   c. `task_update(i, title, "grading")`.
-   d. **Grade** — call `grade({ prompt: "Evaluate the result against the request's intent and general quality. Output PASS or FAIL on the first line, then the reason.\\nRequest: {user request}\\nTask: {title}" })`.
-   e. Parse the verdict:
+   b. **Generate** — call `generate({ prompt: "Task: {title}. Perform it for real in the current directory (write/edit files)." })`. The generator model runs in a sub-session and writes files directly — its return value is a summary, NOT the work itself.
+   c. **Verify the work** — after generate returns, read the files it should have produced (use `read`/`glob`) to confirm the work actually exists and is non-trivial. Do not trust the summary alone.
+   d. `task_update(i, title, "grading")`.
+   e. **Grade** — call `grade({ prompt: "Evaluate the result against the request's intent and general quality. Output PASS or FAIL on the first line, then the reason.\\nRequest: {user request}\\nTask: {title}" })`. The grade tool normalizes the verdict: PASS/FAIL is always on the first line.
+   f. Parse the verdict (first non-empty line):
       - `PASS` → `task_update(i, title, "completed", score:"PASS")` → next.
-      - `FAIL` and revisions < 2 → `task_update(i, title, "revising", revisions:k)` → `generate({ prompt: "Apply the grading feedback and improve:\\n{grade result}\\nTask: {title}" })` → back to (c) re-grade.
+      - `FAIL` and revisions < 2 → `task_update(i, title, "revising", revisions:k)` → `generate({ prompt: "Apply the grading feedback and improve:\\n{grade result}\\nTask: {title}" })` → back to (d) re-grade.
       - `FAIL` and revisions exhausted → `task_update(i, title, "failed", score:"FAIL")` → next.
+   g. **Error handling:** if `generate` returns text starting with `ERROR:` or `[runModel TIMEOUT`, the sub-session failed. Log it via `task_update(i, title, "failed")` and continue to the next task — do not loop forever on a broken task.
 3. When all tasks are done → `harness_done()`.
 
 ## Rules

package/dist/index.js

@@ -74,23 +74,40 @@ function readHarnessCfg(dir) {
 }
 async function runModel(client, model, prompt, directory) {
   const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+  const t0 = Date.now();
   try {
     const slash = model.indexOf("/");
     const providerID = slash >= 0 ? model.slice(0, slash) : model;
     const modelID = slash >= 0 ? model.slice(slash + 1) : "";
     const s = await client.session.create({ body: { title: "uc-harness-sub" }, query: { directory } });
     const id = s?.data?.info?.id;
-    if (!id) return null;
+    if (!id) {
+      log(`runModel(${model}): no session id returned`);
+      return null;
+    }
+    log(`runModel(${model}): session ${id} created, prompt ${prompt.length} chars`);
     await client.session.prompt({
       path: { id },
       body: { model: { providerID, modelID }, parts: [{ type: "text", text: prompt }] }
     });
+    let lastStatus = "";
+    let timedOut = false;
     for (let i = 0; i < 600; i++) {
       await sleep(1e3);
       const st = await client.session.status({ path: { id } });
       const status = st?.data?.[id]?.status ?? st?.data?.status;
-      if (status === "idle" || status === "completed" || !status) break;
+      if (status !== lastStatus) {
+        log(`runModel(${model}): poll ${i}s status="${status}"`);
+        lastStatus = String(status);
+      }
+      if (status === "idle" || status === "completed") break;
+      if (status === "error" || status === "failed") {
+        log(`runModel(${model}): sub-session ended with "${status}"`);
+        break;
+      }
+      if (i === 599) timedOut = true;
     }
+    const elapsed = Math.round((Date.now() - t0) / 1e3);
     const msgs = await client.session.messages({ path: { id } });
     const all = msgs?.data ?? [];
     const lastAssistant = all.filter((m) => m?.info?.role === "assistant").pop();
@@ -100,13 +117,15 @@ async function runModel(client, model, prompt, directory) {
       await client.session.remove?.({ path: { id } });
     } catch {
     }
+    log(`runModel(${model}): done ${elapsed}s, ${text.length} chars${timedOut ? " [TIMEOUT]" : ""}`);
+    if (timedOut) return `[runModel TIMEOUT after ${elapsed}s \u2014 result may be incomplete]
+${text.trim()}`;
     return text.trim() || null;
   } catch (e) {
-    log(`runModel err (${model}): ${String(e)}`);
+    log(`runModel err (${model}, ${Math.round((Date.now() - t0) / 1e3)}s): ${String(e)}`);
     return null;
   }
 }
-var PROVIDER = process.env.UC_PROVIDER ?? "zai";
 var num = (e, d) => {
   try {
     const v = Number(process.env[e]);
@@ -120,7 +139,6 @@ var THR_5H = num("UC_THROTTLE_5H", 70);
 var STOP_WK = num("UC_STOP_WEEKLY", 95);
 var THR_WK = num("UC_THROTTLE_WEEKLY", 85);
 var STOP_MO = num("UC_STOP_MONTHLY", 98);
-var LIGHTER = process.env.UC_LIGHTER_MODEL ?? "glm-4.5-air";
 function humanRemaining(iso) {
   try {
     if (!iso) return "";
@@ -191,12 +209,13 @@ async function fetchProvidersCoach() {
   }));
   return results.filter(Boolean);
 }
-function fetchQuota() {
+function fetchQuota(provider) {
   return new Promise((resolve2) => {
     let out = "";
     let p;
     try {
-      p = spawn("codexbar", ["usage", "--provider", PROVIDER, "--json"], {
+      const args = provider ? ["usage", "--provider", provider, "--json"] : ["usage", "--json"];
+      p = spawn("codexbar", args, {
         stdio: ["ignore", "pipe", "ignore"]
       });
     } catch {
@@ -219,12 +238,12 @@ function fetchQuota() {
     });
   });
 }
-function coach(q) {
+function coach(q, lighter) {
   if (!q) return { decision: "GO", advice: "quota unavailable \u2014 proceeding cautiously.", weekly: -1, monthly: -1, fiveHour: -1 };
   const wk = Math.round(q.weekly?.usedPercent ?? 0), mo = Math.round(q.monthly?.usedPercent ?? 0), h5 = Math.round(q.fiveHour?.usedPercent ?? 0);
   const wkR = humanRemaining(q.weekly?.resetsAt), h5R = humanRemaining(q.fiveHour?.resetsAt);
   const stop = (r) => ({ decision: "STOP", advice: `STOP recommend \u2014 ${r}. window nearly exhausted. stop now or it will be force-blocked.`, weekly: wk, monthly: mo, fiveHour: h5 });
-  const thr = (r) => ({ decision: "THROTTLE", advice: `Throttle recommend \u2014 ${r}. switch to lighter model (${LIGHTER}) or wait for window reset.`, weekly: wk, monthly: mo, fiveHour: h5 });
+  const thr = (r) => ({ decision: "THROTTLE", advice: `Throttle recommend \u2014 ${r}. switch to lighter model (${lighter}) or wait for window reset.`, weekly: wk, monthly: mo, fiveHour: h5 });
   if (h5 >= STOP_5H) return stop(`5h window ${h5}% (${h5R})`);
   if (wk >= STOP_WK) return stop(`weekly ${wk}% (${wkR})`);
   if (mo >= STOP_MO) return stop(`monthly ${mo}%`);
@@ -236,6 +255,9 @@ var LOADING = { decision: "GO", advice: "quota loading\u2026", weekly: -1, month
 async function UsageCoachPlugin(input) {
   try {
     setStateDir(input.directory);
+    const cfg0 = readHarnessCfg(input.directory);
+    const PROVIDER = process.env.UC_PROVIDER ?? cfg0.provider ?? "";
+    const LIGHTER = process.env.UC_LIGHTER_MODEL ?? cfg0.lighterModel ?? "a lighter model";
     let last = null;
     let lastFetchedAt = 0;
     let refreshing = false;
@@ -244,9 +266,9 @@ async function UsageCoachPlugin(input) {
         if (refreshing) return;
         if (last && Date.now() - lastFetchedAt < TTL_MS) return;
         refreshing = true;
-        fetchQuota().then(async (q) => {
+        fetchQuota(PROVIDER).then(async (q) => {
           try {
-            last = coach(q);
+            last = coach(q, LIGHTER);
             lastFetchedAt = Date.now();
             let providers = [];
             try {
@@ -356,9 +378,9 @@ async function UsageCoachPlugin(input) {
           args: { prompt: tool.schema.string() },
           async execute(args, ctx) {
             const cfg = readHarnessCfg(ctx.directory);
-            const model = cfg.generator ?? "zai-coding-plan/glm-5.1";
-            const out = await runModel(input.client, model, args.prompt, ctx.directory);
-            return out ?? `(generator ${model} produced no text)`;
+            if (!cfg.generator) return 'ERROR: no generator model configured. Set "generator" in harness.config.json (see harness.config.example.json).';
+            const out = await runModel(input.client, cfg.generator, args.prompt, ctx.directory);
+            return out ?? `(generator ${cfg.generator} produced no text)`;
           }
         }),
         generate_batch: tool({
@@ -366,9 +388,9 @@ async function UsageCoachPlugin(input) {
           args: { tasks: tool.schema.array(tool.schema.object({ id: tool.schema.number(), prompt: tool.schema.string() })) },
           async execute(args, ctx) {
             const cfg = readHarnessCfg(ctx.directory);
-            const model = cfg.generator ?? "zai-coding-plan/glm-5.1";
+            if (!cfg.generator) return 'ERROR: no generator model configured. Set "generator" in harness.config.json (see harness.config.example.json).';
             const results = await Promise.all(args.tasks.map(async (t) => {
-              const out = await runModel(input.client, model, t.prompt, ctx.directory);
+              const out = await runModel(input.client, cfg.generator, t.prompt, ctx.directory);
               return `[task ${t.id}] ${out ?? "(no output)"}`;
             }));
             return results.join("\n\n");
@@ -379,9 +401,20 @@ async function UsageCoachPlugin(input) {
           args: { prompt: tool.schema.string() },
           async execute(args, ctx) {
             const cfg = readHarnessCfg(ctx.directory);
-            const model = cfg.grader ?? cfg.generator ?? "opencode/mimo-v2.5-free";
+            const model = cfg.grader ?? cfg.generator;
+            if (!model) return 'FAIL\n(ERROR: no grader/generator model configured. Set "grader" and "generator" in harness.config.json.)';
             const out = await runModel(input.client, model, args.prompt, ctx.directory);
-            return out ?? `(grader ${model} produced no text)`;
+            if (!out) return "FAIL\n(grader produced no output \u2014 treating as FAIL to trigger a revise)";
+            const firstLine = out.split("\n").find((l) => l.trim()) ?? "";
+            const f = firstLine.trim();
+            const isPass = /^pass\b/i.test(f);
+            const isFail = /^fail\b/i.test(f);
+            if (!isPass && !isFail) {
+              return `FAIL
+(grader did not output PASS/FAIL on the first line; defaulting to FAIL to trigger a revise)
+${out}`;
+            }
+            return out;
           }
         })
       }

package/dist/tui.js

@@ -5,7 +5,7 @@ import { effect as _$effect } from "@opentui/solid";
 import { createTextNode as _$createTextNode } from "@opentui/solid";
 import { insertNode as _$insertNode } from "@opentui/solid";
 import { createElement as _$createElement } from "@opentui/solid";
-import { readFileSync, existsSync, writeFileSync, mkdirSync } from "fs";
+import { readFileSync, existsSync, writeFileSync, mkdirSync, readdirSync, statSync } from "fs";
 import { createHash } from "crypto";
 import { homedir } from "os";
 import { join, resolve } from "path";
@@ -29,8 +29,44 @@ function readState() {
 }
 function readHarness() {
   try {
-    if (!existsSync(HARNESS_FILE)) return null;
-    return JSON.parse(readFileSync(HARNESS_FILE, "utf8"));
+    let best = null;
+    let entries = [];
+    try {
+      entries = readdirSync(STATE_DIR);
+    } catch {
+    }
+    for (const d of entries) {
+      const sub = join(STATE_DIR, d);
+      let isDir = false;
+      try {
+        isDir = statSync(sub).isDirectory();
+      } catch {
+      }
+      if (!isDir) continue;
+      const f = join(sub, "harness.json");
+      if (!existsSync(f)) continue;
+      let st;
+      try {
+        st = statSync(f);
+      } catch {
+        continue;
+      }
+      let active = false;
+      try {
+        active = !!JSON.parse(readFileSync(f, "utf8")).active;
+      } catch {
+      }
+      if (!best || active && !best.active || active === best.active && st.mtimeMs > best.mtime) {
+        best = {
+          file: f,
+          mtime: st.mtimeMs,
+          active
+        };
+      }
+    }
+    if (best) return JSON.parse(readFileSync(best.file, "utf8"));
+    if (existsSync(HARNESS_FILE)) return JSON.parse(readFileSync(HARNESS_FILE, "utf8"));
+    return null;
   } catch {
     return null;
   }
@@ -334,7 +370,7 @@ function initializeTui(api, disposeRoot) {
           _$effect((_$p) => _$setProp(_el$59, "style", st(sKey), _$p));
           return _el$59;
         })());
-        const pv = t.model ? t.model.startsWith("zai") ? "zai" : (t.model.split("/")[0] ?? "").split("-")[0] : "";
+        const pv = t.model ? (t.model.split("/")[0] ?? "").split("-")[0] : "";
         const q = pv && h.quotas?.[pv] ? h.quotas[pv] : null;
         const pct = q ? q.fiveHour : 0;
         nodes.push((() => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-usage-coach",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "opencode closed-loop usage coach \u2014 quota SENSE -> coaching DECIDE -> loop ACT + TUI integration",
   "type": "module",
   "main": "./dist/index.js",
@@ -33,8 +33,8 @@
     "usage",
     "coach",
     "loop",
-    "zai",
-    "glm"
+    "llm",
+    "harness"
   ],
   "license": "MIT",
   "peerDependencies": {