opencode-harness-kit 0.4.2 → 0.4.4

package/src/config.js

@@ -30,7 +30,9 @@ import {
 } from "./profile.js"
 
 import { join } from "node:path"
+import { readFileSync } from "node:fs"
 import { homedir } from "node:os"
+import { BASH_DENYLIST } from "./denylist.js"
 
 /** @typedef {import("./profile.js").Profile} Profile */
 
@@ -61,6 +63,121 @@ export function globalInstructionsPath() {
  */
 export const GLOBAL_INSTRUCTIONS = "~/.config/opencode/GLOBAL.md"
 
+/**
+ * The kit's own version, read from its package.json.
+ *
+ * @returns {string}
+ */
+export function kitVersion() {
+  try {
+    const pkg = JSON.parse(
+      readFileSync(new URL("../package.json", import.meta.url), "utf8"),
+    )
+    return String(pkg.version ?? "unknown")
+  } catch {
+    return "unknown"
+  }
+}
+
+/**
+ * The memory plugin this kit can turn on.
+ *
+ * The kit does not implement memory. A local vector store with embeddings, a
+ * web UI and auto-capture is a large thing to build badly, and there is one
+ * that is already good: `opencode-mem` (MIT). What the kit can do is make it
+ * one flag away, and keep the config honest about it.
+ */
+export const MEMORY_PLUGIN = "opencode-mem@latest"
+
+/**
+ * The config with the memory plugin turned on.
+ *
+ * The plugin list is preserved. The user's own plugins are not the kit's to
+ * remove, and the entry is added rather than replaced so a config that
+ * already has it does not grow a second copy.
+ *
+ * opencode v1 calls the key `plugin` and v2 calls it `plugins`; whichever
+ * the config already uses is the one that is extended.
+ *
+ * @param {any} base the config as it is on disk
+ * @param {string} [spec] the plugin id, so a pinned version or a mirror works
+ * @returns {any}
+ */
+export function withMemoryPlugin(base, spec = MEMORY_PLUGIN) {
+  const b = base ?? {}
+  const key = Array.isArray(b.plugins) ? "plugins" : "plugin"
+  const existing = b[key]
+  if (existing !== undefined && !Array.isArray(existing)) {
+    // The value is not a list. Appending to it would replace whatever the
+    // user had, so it is left alone.
+    return { ...b }
+  }
+  const list = Array.isArray(existing) ? [...existing] : []
+  if (!list.includes(spec)) list.push(spec)
+  return { ...b, [key]: list }
+}
+
+/**
+ * Whether the memory plugin can be added to this config.
+ *
+ * A config whose plugin value is not a list is left alone: replacing a
+ * string with a list is data loss, and the promise is that the user's own
+ * plugins are never touched.
+ *
+ * @param {any} base
+ * @returns {boolean}
+ */
+export function canAddMemoryPlugin(base) {
+  const b = base ?? {}
+  const key = Array.isArray(b.plugins) ? "plugins" : "plugin"
+  const existing = b[key]
+  return existing === undefined || Array.isArray(existing)
+}
+
+/**
+ * The utility route a profile names, as a full model id.
+ *
+ * `small_model` is opencode's route for the short auxiliary calls. It used to
+ * be the session model, so every title and every rewritten question paid the
+ * session model's reasoning - and reasoning, not output, is what a short call
+ * costs.
+ *
+ * @param {any} p the profile
+ * @returns {string | null}
+ */
+export function utilityModel(p) {
+  const u = p?.utility
+  if (!u || typeof u.model !== "string" || !u.model) return null
+  return `${p.provider ?? "opencode"}/${u.model}`
+}
+
+/**
+ * The instruction list a generated config carries.
+ *
+ * The kit's own file is always in it. A config that already had an
+ * `instructions` array used to replace it wholesale, which unloaded the
+ * whole behavioural layer while everything still looked correct.
+ *
+ * The user's own files keep their order and come first; the kit's is
+ * appended. Duplicates are dropped, so re-running `use` does not grow the
+ * list.
+ *
+ * @param {string[] | string | undefined} base
+ * @param {string} kitPath
+ * @returns {string[]}
+ */
+export function mergeInstructions(base, kitPath) {
+  const list = Array.isArray(base) ? base.filter((x) => typeof x === "string") : []
+  /** @type {string[]} */
+  const out = []
+  for (const entry of [...list, kitPath]) {
+    if (!entry) continue
+    if (out.includes(entry)) continue
+    out.push(entry)
+  }
+  return out
+}
+
 /**
  * Read-only and verification commands.
  *
@@ -84,7 +201,7 @@ export const BASH_ALLOWLIST = [
   "cd*", "realpath*", "basename*", "dirname*", "readlink*",
   "for*", "set*", "export*", "unset*", "bash*", "sh*", "true*", "false*", "test*",
   "read*", "#*", "xargs*", "seq*", "exit*", ":*",
-  "node*", "python3*", "python*", "npm*", "bun*", "uv*", "go*", "cargo*", "rustc*",
+  "node*", "python3*", "python*", "bun*", "uv*", "go*", "cargo*", "rustc*",
   "opencode*", "sqlite3*", "jq*", "fd*",
   "git status*", "git log*", "git diff*", "git show*", "git branch*",
   "git rev-parse*", "git config --get*", "git remote*", "git blame*",
@@ -103,27 +220,20 @@ export const BASH_ALLOWLIST = [
   "python3 -m pytest*", "python3 -m venv*", "python3 -m compileall*",
   "python3 -c*", "python3 agent/*", "python3 src/*", "python3 -",
   ".venv/bin/python*", "pytest*", "ruff*", "mypy*", "black*",
-  "npm test*", "npm run *", "npm ci*", "npm ls*", "npm view *",
-  "npx*", "uv run *", "uv pip *", "bun run *", "bunx*", "node -e*",
+  "npm test*", "npm run *", "npm ls*", "npm view *", "npm outdated*",
+  "npx tsc*", "npx eslint*", "npx prettier*",
+  "uv run *", "uv pip *", "bun run *", "bunx*", "node -e*",
   "opencode debug*", "opencode --version*", "opencode models*",
 ]
 
-/** Hard blocks. The guard plugin enforces the same set in code. */
-export const BASH_DENYLIST = [
-  // `git push` is intentionally absent: it falls through to the `*` ask rule
-  // so opencode prompts for human approval before publishing.
-  "rm -rf *",
-  "rm -fr *",
-  "curl * | sh",
-  "curl * | bash",
-  "chmod 777 *",
-  "chmod 777*",
-  "gh pr create*",
-  "gh pr merge*",
-  "gh pr close*",
-  "gh release*",
-  "gh repo delete*",
-]
+/**
+ * Hard blocks.
+ *
+ * The list lives in ./denylist.js because it is enforced in TWO places: by
+ * opencode's permission map, and by the guard plugin. The two used to be
+ * different lists, and the comment here claimed they were the same.
+ */
+export { BASH_DENYLIST } from "./denylist.js"
 
 /**
  * @param {Profile} p
@@ -214,10 +324,21 @@ export function generateConfig(p, opts = {}) {
     ...base_,
 
     model,
-    // Same model, not a cheaper one: swapping models mid-session changes the
-    // voice and the tool habits. Lower the effort instead. An inherited
-    // small_model pointing at a different model is replaced, not preserved.
-    small_model: model,
+    // The utility route, when the profile names one.
+    //
+    // `small_model` is what opencode uses for the short auxiliary calls: a
+    // title, a one-line summary, a question rewritten. It used to be the same
+    // model as the session, which meant every one of those calls paid the
+    // session model's reasoning - and reasoning, not output, is what a short
+    // call costs. Measured on this tier, a title costs 49 reasoning tokens on
+    // deepseek and 332 on nemotron-3.5-super-vl, and deepseek answers in
+    // 7.2s against 22.7s for glm.
+    //
+    // A profile that does not name a utility route keeps the session model.
+    // A single-model profile SHOULD keep it: "one route, and it is the one
+    // you asked for" is a promise the five-lane profiles make, and a cheaper
+    // route on the side would break it.
+    small_model: utilityModel(p) ?? model,
     // No top-level `variant`. The 1.18.35 Config schema sets
     // `additionalProperties: false` and has no `variant` key, so OpenCode
     // strips it from the resolved config - verified with `opencode debug
@@ -231,16 +352,26 @@ export function generateConfig(p, opts = {}) {
     subagent_depth: base.subagent_depth ?? 2,
     // Omitting `lsp` disables it entirely, so this must be set explicitly.
     lsp: base.lsp ?? true,
-    instructions: base.instructions ?? [instructionsPath],
+    // The kit's own instruction file is always in the list.
+    //
+    // It used to be `base.instructions ?? [instructionsPath]`, so a config
+    // that already had an `instructions` array never referenced GLOBAL.md at
+    // all: the whole behavioural layer - the lane table, the rules, the
+    // read-pressure guidance - was silently unloaded, and `verify` still
+    // passed because it only checked the paths the config did name. The
+    // user's own files keep their order and come first; the kit's is
+    // appended, because it is the layer that has to hold when the others
+    // do not.
+    instructions: mergeInstructions(base.instructions, instructionsPath),
 
     compaction,
     // OpenCode's own default (2000 lines / 51200 bytes), reached back from an
-    // earlier 200 / 8192. The tight setting truncated 415 of 2,959 measured
-    // `read` calls, and 418 calls were issued with an `offset` to fetch the
+    // earlier 200 / 8192. The tight setting truncated 415 of 2,966 measured
+    // `read` calls, and 423 calls were issued with an `offset` to fetch the
     // rest: the truncation causes the re-read, one for one. At the measured
     // 17.3s median per request that round trip costs far more than the tokens
     // it saves, and prune.ts already bounds old tool output deterministically.
-    // Only 14 of 2,959 reads exceed 51,200 bytes, so this ceiling is not the
+    // Only 14 of 2,966 reads exceed 51,200 bytes, so this ceiling is not the
     // thing that limits context. `oc-harness baseline` re-measures all four
     // numbers if this ever needs arguing again.
     tool_output: { max_lines: 2000, max_bytes: 51200 },
@@ -278,13 +409,17 @@ export function generateConfig(p, opts = {}) {
 
     agent,
 
-    // The router plugin reads this at startup to know which fallback queue to
-    // walk, and it is also how a profile stays identifiable after the config
-    // has been hand-edited.
+    // How a profile stays identifiable after the config has been hand-edited.
+    // The fallback queue is NOT written here: the router reads it straight
+    // from the profile file, and a copy of the first id in a key nothing
+    // reads is a second source of truth that can only drift.
     harness: {
       profile: p.id,
-      ...(p.fallback?.length ? { fallback: p.fallback[0] } : {}),
       threshold: pruneThreshold(p, { unhealthy }),
+      // Which kit wrote this. Without it, a config from three releases ago
+      // and one from today are the same file to `verify`, and the only way
+      // to tell them apart is to remember.
+      kit: kitVersion(),
     },
   }
 
@@ -321,6 +456,11 @@ function render(cfg, p, opts) {
     `${c}`,
     `${c}profile      ${p.id}`,
     `${c}model        ${p.provider}/${p.model}`,
+    ...(p.utility
+      ? [
+          `${c}utility      ${p.provider}/${p.utility.model}  (opencode's short calls: titles, summaries)`,
+        ]
+      : []),
     ...(splits.length
       ? [
           `${c}lanes        ${splits.length} enabled, each on the first model its chain allows`,
@@ -345,7 +485,17 @@ function render(cfg, p, opts) {
     `${c}Derived numbers, do not hand-edit:`,
     `${c}  compaction.reserved  ${reservedTokens(p, { unhealthy }).toLocaleString("en-US")}  (${Math.round((p.effort?.reserveShare ?? 0.12) * 100)}% of the narrowest input cap in play, held back for reasoning growth)`,
     `${c}  prune threshold      ${pruneThreshold(p, { unhealthy }).toLocaleString("en-US")}  (narrowest input cap minus reserve)`,
-    `${c}  role effort          ${Object.entries(roles).map(([k, v]) => `${k}=${v ?? "unset"}`).join("  ")}`,
+    `${c}  role effort          ${Object.entries(roles)
+      .map(([k, v]) => {
+        // A lane that asked for a tier and did not get one says so HERE,
+        // in the file the user reads. The reason it is in the file and not
+        // only in `oc-harness show` is that the file is what a human
+        // looks at when a lane turns out to be slow.
+        const want = p.roles?.[k]
+        const dropped = want && want !== "none" && v !== want
+        return `${k}=${v ?? "unset"}${dropped ? `(asked ${want})` : ""}`
+      })
+      .join("  ")}`,
     ...(laneRows.length
       ? [
           `${c}  lane models          ${laneRows.map((r) => `${r.role}=${r.model}${r.limits ? ` (out ${r.limits.output.toLocaleString("en-US")})` : ""}`).join("  ")}`,

package/src/denylist.js

@@ -0,0 +1,95 @@
+// The commands that are never allowed, in one place.
+//
+// This list is the MECHANICAL half of the kit's safety policy, and it is
+// enforced in two places: by opencode's permission map, and by the guard
+// plugin. Before this module existed, the two were different lists - the
+// config denied `gh pr create` and `npm publish`, and the guard blocked
+// neither - so the config's own comment, "the guard plugin enforces the same
+// set in code", was false.
+//
+// One list, two enforcers. If it is not in here, the guard does not block it.
+//
+// A pattern is a glob: `*` matches anything. The patterns are matched
+// against the COMMAND, not against a subcommand, so `rm -rf *` means "a
+// command that starts with `rm -rf `".
+
+/** @type {string[]} */
+export const BASH_DENYLIST = [
+  // `git push` is intentionally absent: it falls through to the `*` ask rule
+  // so opencode prompts for human approval before publishing.
+  "rm -rf *",
+  "rm -fr *",
+  "curl * | sh",
+  "curl * | bash",
+  "chmod 777 *",
+  "chmod 777*",
+  "gh pr create*",
+  "gh pr merge*",
+  "gh pr close*",
+  "gh release*",
+  "gh repo delete*",
+  // Publishing to a registry. The allowlist had a blanket `npm*`, so
+  // `npm publish` was ALLOWED - no prompt, no question - while GLOBAL.md says
+  // to ask before publishing. The mechanical layer contradicted the judgement
+  // layer, which is the exact failure this kit is built to catch.
+  //
+  // The registry is the one destination where a mistake cannot be undone by
+  // deleting a file.
+  "npm publish*",
+  "npm unpublish*",
+  "npm deprecate*",
+  "npm login*",
+  "npm adduser*",
+  "npm token *",
+  "npm owner *",
+  "yarn publish*",
+  "pnpm publish*",
+  "bun publish*",
+]
+
+/**
+ * Whether a glob pattern matches a command.
+ *
+ * `*` matches any run of characters, including none.
+ *
+ * @param {string} command
+ * @param {string} pattern
+ * @returns {boolean}
+ */
+export function matchesPattern(command, pattern) {
+  const re = new RegExp(
+    "^" +
+      pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[\\s\\S]*") +
+      "$",
+  )
+  return re.test(command)
+}
+
+/**
+ * The first denied pattern a command matches, or null.
+ *
+ * The command is matched whole, and it is matched by the CONFIG too - the
+ * permission map globs the raw command, because that is the only thing it
+ * can see. So this function is the flat, literal half.
+ *
+ * The guard does not stop here. It calls this on each SEGMENT, with the
+ * wrappers stripped and the payload of a `bash -c` followed, so
+ * `sudo bash -c "npm publish"` is caught as well. The two enforcers read the
+ * same list and one of them reads it more carefully; that is the price of
+ * having the list in two places.
+ *
+ * The two PIPE patterns are for the config's side only. `segments()` splits
+ * on `|`, so a segment never contains " | sh" and the guard catches a piped
+ * script through its own rule instead.
+ *
+ * @param {string} command
+ * @returns {string | null}
+ */
+export function deniedBy(command) {
+  const cmd = String(command ?? "").trim()
+  if (!cmd) return null
+  for (const pattern of BASH_DENYLIST) {
+    if (matchesPattern(cmd, pattern)) return pattern
+  }
+  return null
+}

package/src/driver/run.mjs

@@ -43,7 +43,11 @@ const red = (s) => `\x1b[31m${s}\x1b[0m`
  * Never throws: the caller has to be able to write the failure into the task
  * file, which is the only record anyone gets of why a task did not land.
  */
-export function sh(command, { cwd, timeoutMs = 900_000 } = {}) {
+export function sh(
+  command,
+  /** @type {{ cwd?: string, timeoutMs?: number }} */
+  { cwd, timeoutMs = 900_000 } = {},
+) {
   const started = Date.now()
   const res = spawnSync(command, {
     shell: true,
@@ -75,14 +79,22 @@ export function tail(text, n = 12) {
  * the agent actually did rather than being told about it.
  */
 export function invokeAgent(role, prompt, { cwd, timeoutMs }) {
+  // `--dir` is not optional, and neither is PWD.
+  //
+  // `spawnSync`'s `cwd` sets the child's working directory but does NOT update
+  // the inherited `PWD`, and opencode resolves its project directory from
+  // `process.env.PWD ?? process.cwd()`. So the agent was handed the right
+  // directory and worked in the wrong repository - the one the shell happened
+  // to be in. `eval/ab.mjs` documents the same trap and fixes it the same way.
   const res = spawnSync(
     "opencode",
-    ["run", "--agent", role, "--format", "json", prompt],
+    ["run", "--agent", role, "--dir", cwd, "--format", "json", prompt],
     {
       cwd,
       encoding: "utf8",
       timeout: timeoutMs,
       maxBuffer: 64 * 1024 * 1024,
+      env: { ...process.env, PWD: cwd },
     },
   )
   return {
@@ -106,7 +118,7 @@ export function buildPrompt(task) {
     ``,
     `Rules for this run:`,
     `  - Change only the files named above. If the task is wrong or blocked, say so and stop.`,
-    `  - Never run git push, never create a PR, never publish. A human does that.`,
+    `  - Never run git push, never create a PR, never publish. This loop runs unattended, so there is nobody to ask - a human pushes.`,
     `  - Report the real output of the verify command. Never invent a passing result.`,
   ].join("\n")
 }
@@ -117,6 +129,11 @@ export function buildPrompt(task) {
  * Stops at the first of: nothing pending, nothing verifiable, a blocked task, a
  * failing verify, the round cap, or the time budget. Whichever it was gets
  * printed, so a run that stops early always says why.
+ *
+ * The budget is checked BETWEEN rounds. The agent and the verify each get the
+ * time that is left, with a floor of half a minute - so a run can overrun the
+ * budget by that floor plus the time between the check and the call, and not
+ * by the thirty minutes the verify used to be allowed.
  */
 export function runLoop({
   cwd = process.cwd(),
@@ -140,6 +157,31 @@ export function runLoop({
   let text = readFileSync(join(cwd, TASKS_PATH), "utf8")
   let rounds = 0
 
+  /**
+   * The task file, read fresh, and the task we were working on inside it.
+   *
+   * The file is read once at the start and every write used that copy, so
+   * anything the agent wrote - a new task, a corrected verify command, a note
+   * about a blocker - was silently erased by the loop's own write. A human
+   * editing the file while the loop ran lost the same way.
+   *
+   * So the file is read again before every write, and the change is applied to
+   * the CURRENT text. The task is matched by its title, because a line number
+   * from the old copy means nothing in the new one.
+   */
+  const reload = (task) => {
+    let fresh = ""
+    try {
+      fresh = readFileSync(join(cwd, TASKS_PATH), "utf8")
+    } catch {
+      return { text, task }
+    }
+    const parsed = parseTasks(fresh)
+    const same = parsed.tasks.filter((t) => t.title === task.title)[task.ordinal ?? 0]
+    if (!same) return { text, task }
+    return { text: fresh, task: same }
+  }
+
   for (;;) {
     const parsed = parseTasks(text)
     const task = nextPending(parsed)
@@ -153,15 +195,17 @@ export function runLoop({
             : `every task is done (${s.done}/${s.total}).`,
         code: s.blocked > 0 ? 2 : 0,
         summary: s,
+        rounds,
       })
     }
 
     if (isBlocked(task)) {
-      return stop(log, { reason: `task is blocked and needs a person: ${task.title}`, code: 2 })
+      return stop(log, { reason: `task is blocked and needs a person: ${task.title}`, code: 2, rounds })
     }
 
     if (!task.verify) {
-      text = markTask(text, task, {
+      const fresh = reload(task)
+      text = markTask(fresh.text, fresh.task, {
         status: "blocked",
         verifyOutput: "blocked by the loop: this task has no verify command, so nothing could prove it finished.",
       })
@@ -169,29 +213,35 @@ export function runLoop({
       return stop(log, {
         reason: `"${task.title}" has no verify command. It cannot be checked, so it cannot be run unattended. Add one, or do it yourself.`,
         code: 2,
+        rounds,
       })
     }
 
-    rounds++
-    if (rounds > maxRounds) {
-      return stop(log, { reason: `stopped at the round cap (${maxRounds}). Raise it with --max-rounds, or run fewer tasks.`, code: 2 })
+    if (rounds >= maxRounds) {
+      return stop(log, { reason: `stopped at the round cap (${maxRounds}). Raise it with --max-rounds, or run fewer tasks.`, code: 2, rounds })
     }
 
     const elapsed = Date.now() - started
     if (elapsed >= budgetMs) {
-      return stop(log, { reason: `stopped at the time budget (${budgetMinutes} min, ${Math.round(elapsed / 60000)} min used).`, code: 2 })
+      return stop(log, { reason: `stopped at the time budget (${budgetMinutes} min, ${Math.round(elapsed / 60000)} min used).`, code: 2, rounds })
     }
 
+    // The time that is left, with a floor so a nearly-spent budget still gets
+    // a command that can actually finish.
+    const remaining = () => Math.max(30_000, budgetMs - (Date.now() - started))
+
+    rounds++
     console.log(`\n  ${bold(`[${rounds}]`)} ${task.title}`)
     if (task.files) console.log(`      ${stamp(task.files)}`)
 
     const agent = runAgent(role, buildPrompt(task), {
       cwd,
-      timeoutMs: Math.max(60_000, budgetMs - (Date.now() - started)),
+      timeoutMs: remaining(),
     })
     if (!agent.ok) {
       const why = agent.error || agent.output || `exit ${agent.status}`
-      text = markTask(text, task, {
+      const fresh = reload(task)
+      text = markTask(fresh.text, fresh.task, {
         status: "blocked",
         verifyOutput: `blocked by the loop: the ${role} agent failed.\n${tail(why)}`,
       })
@@ -199,6 +249,7 @@ export function runLoop({
       return stop(log, {
         reason: `the ${role} agent failed on "${task.title}": ${tail(why, 3).split("\n")[0]}`,
         code: 3,
+        rounds,
       })
     }
 
@@ -206,11 +257,12 @@ export function runLoop({
     // loop that trusts the agent's own word about whether it passed is a loop
     // that reports success it never checked.
     console.log(`      ${stamp(`verify: ${task.verify}`)}`)
-    const check = runVerify(task.verify, { cwd, timeoutMs: 1800_000 })
+    const check = runVerify(task.verify, { cwd, timeoutMs: remaining() })
     log.push({ round: rounds, task: task.title, ok: check.ok, seconds: check.seconds })
 
     if (!check.ok) {
-      text = markTask(text, task, {
+      const fresh = reload(task)
+      text = markTask(fresh.text, fresh.task, {
         status: "blocked",
         verifyOutput: `verify failed (exit ${check.status}, ${check.seconds}s)\n${tail(check.output)}`,
       })
@@ -218,10 +270,12 @@ export function runLoop({
       return stop(log, {
         reason: `verify failed on "${task.title}". Marked blocked -- the real output is in ${TASKS_PATH}.`,
         code: 4,
+        rounds,
       })
     }
 
-    text = markTask(text, task, {
+    const fresh = reload(task)
+    text = markTask(fresh.text, fresh.task, {
       status: "done",
       verifyOutput: `exit ${check.status} in ${check.seconds}s\n${tail(check.output)}`,
     })
@@ -230,8 +284,19 @@ export function runLoop({
   }
 }
 
-function stop(log, { reason, code, summary }) {
-  return { reason, code: code ?? 0, rounds: log.length, log, summary }
+/**
+ * The outcome of a run.
+ *
+ * @param {any[]} log
+ * @param {{ reason: string, code?: number, summary?: any, rounds?: number }} stop
+ * @returns {{ reason: string, code: number, rounds: number, log: any[], summary?: any }}
+ */
+function stop(log, { reason, code, summary, rounds }) {
+  // `rounds` is the number of rounds the loop RAN, not the number of
+  // entries in the log. The log only gets an entry after a verify that
+  // passed, so a run whose agent died on the first round reported zero
+  // rounds - which reads as "it did nothing" when it did one.
+  return { reason, code: code ?? 0, rounds: rounds ?? log.length, log, summary }
 }
 
 export { TASKS_PATH }

package/src/effort.js

@@ -16,7 +16,8 @@ import { loadProfile, resolveRoles, resolveDefaultVariant, resolveLaneModel, LAN
 /**
  * @typedef {import("./profile.js").Profile} Profile
  * @typedef {import("./profile.js").EffortRequest} EffortRequest
- * @typedef {import("@opencode-ai/plugin").Config} Config
+ * @typedef {object} Config
+ * @property {Record<string, any>} [agent]
  * @typedef {object} EffortResult
  * @property {string} profileId
  * @property {string} model
@@ -54,8 +55,19 @@ export function planEffort(profileId, opts = {}) {
     )
   }
   for (const [role, want] of Object.entries(p.roles ?? {})) {
+    if (!want) continue
     const got = roles[role]
-    if (want && got && want !== got) {
+    if (got === null) {
+      // The request was lost entirely: the lane's model publishes no such
+      // level, so no variant is emitted for it. This is the one adjustment
+      // worth reporting loudly, because it is the one where the lane is not
+      // running at the effort anybody asked for.
+      notes.push(
+        `lane ${role} asked for ${want}; its model does not publish that level, so no variant is set.`,
+      )
+      continue
+    }
+    if (want !== got) {
       notes.push(`lane ${role} asked for ${want}; its model tops out at ${got}.`)
     }
   }
@@ -90,7 +102,7 @@ export function planEffort(profileId, opts = {}) {
  *
  * @param {Config} config
  * @param {EffortResult} result
- * @param {{ fallbackProfileId?: string, sessionModel?: string }} [opts]
+ * @param {{ sessionModel?: string }} [opts]
  * @returns {Config}
  */
 export function applyEffort(config, result, opts = {}) {
@@ -128,7 +140,6 @@ export function applyEffort(config, result, opts = {}) {
   cfg.harness = {
     ...(cfg.harness ?? {}),
     profile: result.profileId,
-    ...(opts.fallbackProfileId ? { fallback: opts.fallbackProfileId } : {}),
   }
 
   return config