opencode-usage-coach 0.1.7 → 0.2.1

package/README.md

@@ -13,15 +13,16 @@ the loop** — and ships a harness agent mode + a deterministic orchestrator.
 - Senses z.ai quota windows via the `codexbar` CLI.
 - 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: quota meters + harness task states + per-model token usage.
+- Surfaces a sidebar panel: per-provider quota meters + harness task states + coaching.
 - Defensive: any plugin error never breaks opencode.
 
-**Harness (two ways):**
-- **Agent mode** (`usage-coach-harness`): triages each request — trivial → do directly;
-  unclear → clarify; substantive → generate(delegate)→grade(delegate)→revise→advance.
-  Conversation-driven, no file required. Adaptive (best-effort).
-- **Deterministic script** (`harness.ts`): `tasks.txt` + `rubric.md` → guaranteed loop.
-  Reliable for batch jobs. Tracks per-model tokens, auto-splits on timeout.
+**Harness (agent mode, 1 terminal):**
+- The `usage-coach-harness` agent triages each request — trivial → do directly;
+  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.
 
 ## Requirements
 - opencode (tested on 1.17.13) with a z.ai coding-plan provider configured.
@@ -118,8 +119,8 @@ opencode's bundled solid); TUI plugins must be compiled + loaded via `tui.json`
 `codexbar` must be called via `spawn` (the `$` BunShell leaks output to the TUI).
 
 ## Status
-- ✅ M0–M2 quota guardian + TUI panel
-- ✅ M3 harness: agent mode (triage) + deterministic script (per-model tokens, auto-split)
-- ⏳ M4 npm packaging
+- ✅ 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`)
 
 License: MIT.

package/agents/usage-coach-harness.md

@@ -11,6 +11,8 @@ permission:
   glob: allow
   grep: allow
   task: allow
+  generate: allow
+  grade: allow
   harness_start: allow
   task_update: allow
   harness_done: allow
@@ -32,32 +34,31 @@ 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.
 
-**Parallel dispatch (independent tasks):** If the decomposed tasks are INDEPENDENT (no data dependency), dispatch them concurrently — issue **multiple `task` calls in the same turn** so they run as parallel subagents. (This is the only reliable parallel path — the deterministic script cannot parallelize due to opencode's single-server model.) Cap concurrency by quota coaching: "big tasks OK" → up to 3-4 parallel; "moderate/small" → 1-2; STOP → don't dispatch. For DEPENDENT tasks (B needs A's output), run sequentially.
+**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`.
+
+**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.
 
 1. Call `harness_start(name, N)` to register the run on the panel.
-2. For each task i (1..N) — in parallel batches when independent:
+2. For each task i (1..N):
    a. `task_update(i, title, "generating")`.
-   b. **Generate** — delegate to a subagent via the `task` tool (`subagent_type: "general"`):
-      prompt: `"Task: {title}. Perform it for real in the current directory (write/edit files, run commands as needed)."`
-      If a subagent is slow or the task looks too large, split it into smaller subtasks (autonomous decomposition).
+   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** — delegate via the `task` tool:
-      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}"`
+   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:
-      - `PASS` → `task_update(i, title, "completed", score:"PASS")` → next task.
-      - `FAIL` and revisions < 2 → `task_update(i, title, "revising", revisions:k)` → delegate a revision (`"Apply the grading feedback and improve:\n{grade result}"`) → go back to (c) to re-grade.
-      - `FAIL` and revisions exhausted → `task_update(i, title, "failed", score:"FAIL")` → next task.
+      - `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 exhausted → `task_update(i, title, "failed", score:"FAIL")` → next.
 3. When all tasks are done → `harness_done()`.
 
 ## Rules
-- In the loop, **delegate the real work** to subagents via the `task` tool — you orchestrate. (Outside the loop, for trivial requests, you may act directly.)
+- In the loop, do NOT do the work yourself — call `generate`/`grade` (they run the configured models). You orchestrate. (Outside the loop, for trivial requests, act directly.)
 - Call `task_update` on every state transition — the sidebar panel reads it for live visibility.
 - Grading criteria come from the user's request, or sensible defaults; ask the user only if it is truly ambiguous and grading matters.
 - If the quota coaching injected into your system prompt says **STOP**, immediately `task_update(current, "halted_quota")` and halt the loop.
-- If a subagent returns an incomplete result, split the task into smaller subtasks.
+- If `generate` returns an incomplete result, split the task into smaller subtasks.
 - Be concise. Report only progress summaries to the user.
 
 ## Output
 - Trivial path: just the direct result.
-- Loop path: the actual results are the files/changes the subagents leave in the directory; at the end report a brief summary (passed / failed / split counts).
+- Loop path: the actual results are the files/changes the generator leaves in the directory; at the end report a brief summary (passed / failed counts).
 

package/dist/index.js

@@ -54,6 +54,43 @@ function writeHarness(h) {
   } catch {
   }
 }
+function readHarnessCfg(dir) {
+  const tryRead = (p) => {
+    try {
+      if (existsSync(p)) return JSON.parse(readFileSync(p, "utf8"));
+    } catch {
+    }
+    return {};
+  };
+  return {
+    ...tryRead(join(homedir(), ".config", "opencode-usage-coach", "harness.config.json")),
+    ...tryRead(join(dir, "harness.config.json"))
+  };
+}
+async function runModel(client, model, prompt, directory) {
+  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;
+    const r = await client.session.prompt({
+      path: { id },
+      body: { model: { providerID, modelID }, parts: [{ type: "text", text: prompt }] }
+    });
+    const parts = r?.data?.parts ?? [];
+    const text = parts.filter((p) => p?.type === "text").map((p) => p?.text ?? "").join("");
+    try {
+      await client.session.remove?.({ path: { id } });
+    } catch {
+    }
+    return text.trim() || null;
+  } catch (e) {
+    log(`runModel err (${model}): ${String(e)}`);
+    return null;
+  }
+}
 var PROVIDER = process.env.UC_PROVIDER ?? "zai";
 var num = (e, d) => {
   try {
@@ -296,6 +333,28 @@ async function UsageCoachPlugin(input) {
             }
             return "Harness complete.";
           }
+        }),
+        // Per-role model execution (config-driven). Runs a NEW session with the configured model
+        // on the same server — enables multi-model (e.g. GLM generate + free mimo grade) in 1 terminal.
+        generate: tool({
+          description: "Run the GENERATOR model (from harness.config.json) on a prompt. Returns the model's text response. The generator can use tools (write/edit files) in the directory. Use for the 'do the work' step.",
+          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)`;
+          }
+        }),
+        grade: tool({
+          description: "Run the GRADER model (from harness.config.json) on a prompt. Returns the model's text response (expect PASS/FAIL on the first line). Use for the 'evaluate the result' step. Falls back to the generator if the grader has no quota.",
+          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 out = await runModel(input.client, model, args.prompt, ctx.directory);
+            return out ?? `(grader ${model} produced no text)`;
+          }
         })
       }
     };

package/dist/tui.js

@@ -379,17 +379,6 @@ function initializeTui(api, disposeRoot) {
             return _el$72;
           })();
         }
-      },
-      home_footer(ctx) {
-        try {
-          return panel(ctx);
-        } catch {
-          return (() => {
-            var _el$74 = _$createElement("text");
-            _$insertNode(_el$74, _$createTextNode(`usage-coach`));
-            return _el$74;
-          })();
-        }
       }
     }
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-usage-coach",
-  "version": "0.1.7",
+  "version": "0.2.1",
   "description": "opencode closed-loop usage coach \u2014 quota SENSE -> coaching DECIDE -> loop ACT + TUI integration",
   "type": "module",
   "main": "./dist/index.js",