opencode-harness-kit 0.4.2 → 0.4.4

package/dist/index.js

@@ -1,10 +1,64 @@
 // src/index.ts
 import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync2 } from "node:fs";
-import { join as join5 } from "node:path";
+import { join as join8 } from "node:path";
+
+// src/guard.ts
+import { homedir as homedir2, tmpdir as tmpdir2 } from "node:os";
+import { join as join3, resolve as resolve2 } from "node:path";
 
 // src/rules.js
 import { homedir, tmpdir } from "node:os";
 import { resolve as resolvePath, sep } from "node:path";
+
+// src/denylist.js
+var 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*"
+];
+function matchesPattern(command, pattern) {
+  const re = new RegExp(
+    "^" + pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[\\s\\S]*") + "$"
+  );
+  return re.test(command);
+}
+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;
+}
+
+// src/rules.js
 var CASE_INSENSITIVE_FS = process.platform === "darwin" || process.platform === "win32";
 function expandHome(p) {
   if (p === "~") return homedir();
@@ -84,9 +138,17 @@ function segments(command) {
       if (command[i + 1] === "|") i++;
       continue;
     }
-    if (ch === "&" && command[i + 1] === "&") {
+    if (ch === "&") {
+      if (command[i - 1] === ">" || command[i + 1] === ">") {
+        cur += ch;
+        continue;
+      }
+      if (command[i + 1] === "&") {
+        flush();
+        i++;
+        continue;
+      }
       flush();
-      i++;
       continue;
     }
     cur += ch;
@@ -138,8 +200,38 @@ function tokenize(segment) {
   return tokens;
 }
 var ENV_ASSIGN = /^[A-Za-z_][A-Za-z0-9_]*=/;
-var GIT_WRAPPERS = /* @__PURE__ */ new Set(["env", "sudo", "doas", "nohup", "time", "command", "exec", "xargs"]);
+var GIT_WRAPPERS = /* @__PURE__ */ new Set([
+  "env",
+  "sudo",
+  "doas",
+  "nohup",
+  "time",
+  "command",
+  "exec",
+  "xargs",
+  "npx"
+]);
 var WRAPPER_VALUE_FLAGS = /* @__PURE__ */ new Set(["-u", "--user", "-g", "--group", "-I", "-P", "-n", "-a", "-d"]);
+var GIT_VALUE_FLAGS = /* @__PURE__ */ new Set([
+  "-C",
+  "-c",
+  "--git-dir",
+  "--work-tree",
+  "--namespace",
+  "--super-prefix",
+  "--exec-path",
+  "--config-env"
+]);
+var GIT_GLOBAL_FLAGS = /* @__PURE__ */ new Set([
+  "--bare",
+  "--no-pager",
+  "--paginate",
+  "--no-replace-objects",
+  "--no-optional-locks",
+  "--literal-pathspecs",
+  "--glob-pathspecs",
+  "--icase-pathspecs"
+]);
 function skipPrefixes(tokens) {
   let i = 0;
   for (; ; ) {
@@ -170,17 +262,40 @@ function stripPrefixes(segment) {
   if (slash !== -1) rest[0] = rest[0].slice(slash + 1);
   return rest.join(" ");
 }
+function gitSubcommand(segment) {
+  const tokens = tokenize(segment);
+  let i = skipPrefixes(tokens);
+  if (i >= tokens.length) return null;
+  if (!/(^|[\\/])git(\.exe)?$/i.test(tokens[i])) return null;
+  i++;
+  while (i < tokens.length) {
+    const flag = tokens[i];
+    if (GIT_VALUE_FLAGS.has(flag)) {
+      i += 2;
+      continue;
+    }
+    if (/^--[A-Za-z][\w-]*=/.test(flag) || GIT_GLOBAL_FLAGS.has(flag)) {
+      i++;
+      continue;
+    }
+    break;
+  }
+  return tokens[i] ?? null;
+}
 var SHELL_BIN = /(^|[\\/])(sh|bash|zsh|dash|ksh)(\.exe)?$/i;
 var MAX_SHELL_DEPTH = 2;
 function shellPayload(segment) {
   const tokens = tokenize(segment);
   if (tokens.length < 2) return null;
-  if (tokens[0] === "eval") return tokens.slice(1).join(" ") || null;
-  if (!SHELL_BIN.test(tokens[0])) return null;
-  const c = tokens.findIndex((t) => /^-[a-zA-Z]*c$/.test(t));
+  const i = skipPrefixes(tokens);
+  if (i >= tokens.length) return null;
+  if (tokens[i] === "eval") return tokens.slice(i + 1).join(" ") || null;
+  if (!SHELL_BIN.test(tokens[i])) return null;
+  const c = tokens.findIndex((t, n) => n > i && /^-[a-zA-Z]*c$/.test(t));
   if (c === -1 || c === tokens.length - 1) return null;
   return tokens.slice(c + 1).join(" ") || null;
 }
+var ASK_GATED = [/^\s*git\s+push\b/];
 var BASH_RULES = [
   {
     name: "secret exfiltration via shell",
@@ -218,7 +333,18 @@ var BASH_RULES = [
   {
     name: "history rewrite",
     scope: "segment",
-    test: /^git\s+(reset\s+--hard|clean\s+-[a-zA-Z]*f|rebase\s+.*--force)/i,
+    // The subcommand is resolved rather than read off the front of the text,
+    // because git takes options before it: `git -C /repo reset --hard` is the
+    // same command as `git reset --hard`, and a rule anchored at `^git` is
+    // defeated by every one of them. `gitSubcommand` already knows which
+    // options take a value and which ones are global.
+    check: (text) => {
+      const sub = gitSubcommand(text);
+      if (sub === "reset") return /(^|\s)--hard(\s|$)/.test(text);
+      if (sub === "clean") return /(^|\s)-[a-zA-Z]*f/.test(text);
+      if (sub === "rebase") return /(^|\s)--force/.test(text);
+      return false;
+    },
     why: "destroys work that only exists locally"
   }
 ];
@@ -249,6 +375,24 @@ function matches(rule, text) {
   if (!rule.test?.test(text)) return false;
   return !rule.unless?.test(text);
 }
+function checkDenied(command, depth = 0) {
+  if (!command || !command.trim()) return null;
+  const parts = segments(command);
+  const normalized = parts.map((seg) => stripPrefixes(seg));
+  for (let i = 0; i < parts.length; i++) {
+    const pattern = deniedBy(normalized[i]);
+    if (pattern) return { pattern, segment: parts[i] };
+  }
+  if (depth < MAX_SHELL_DEPTH) {
+    for (const seg of parts) {
+      const payload = shellPayload(seg);
+      if (!payload) continue;
+      const hit = checkDenied(payload, depth + 1);
+      if (hit) return hit;
+    }
+  }
+  return null;
+}
 function checkBash(command, rules = BASH_RULES, depth = 0) {
   if (!command || !command.trim()) return null;
   const parts = segments(command);
@@ -288,8 +432,82 @@ function checkWrite(target, rules = WRITE_RULES, root = "") {
   return null;
 }
 
+// src/telemetry-store.ts
+import { appendFileSync, existsSync, mkdirSync, statSync, renameSync } from "node:fs";
+import { join } from "node:path";
+var MAX_BYTES = 4 * 1024 * 1024;
+function logPath(dir) {
+  return join(dir, "telemetry.jsonl");
+}
+function rotate(file) {
+  try {
+    if (existsSync(file) && statSync(file).size > MAX_BYTES) {
+      renameSync(file, `${file}.1`);
+    }
+  } catch {
+  }
+}
+function write(dir, record) {
+  try {
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    const file = logPath(dir);
+    rotate(file);
+    appendFileSync(file, JSON.stringify({ t: (/* @__PURE__ */ new Date()).toISOString(), ...record }) + "\n");
+  } catch {
+  }
+}
+
+// src/project.js
+import { existsSync as existsSync2 } from "node:fs";
+import { dirname, join as join2, resolve } from "node:path";
+function projectRoot(directory, worktree) {
+  const start = resolve(directory || worktree || ".");
+  let dir = start;
+  for (let i = 0; i < 64; i++) {
+    if (existsSync2(join2(dir, ".git"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return start;
+}
+
 // src/guard.ts
 var MARKER = "[opencode-harness-kit] blocked";
+var WRITE_TOOLS = /* @__PURE__ */ new Set(["write", "edit", "apply_patch", "patch"]);
+function pathsInPatch(text) {
+  const out = [];
+  const push = (p) => {
+    const v = p.trim();
+    if (!v) return;
+    if (v === "/dev/null") return;
+    if (!out.includes(v)) out.push(v);
+  };
+  for (const m of text.matchAll(/^\*\*\*\s+(?:Add|Update|Delete)\s+File:\s*(.+)$/gm)) {
+    push(m[1]);
+  }
+  for (const m of text.matchAll(/^\+\+\+\s+(?:b\/)?(.+)$/gm)) {
+    push(m[1]);
+  }
+  return out;
+}
+function writeTargets(tool, args) {
+  if (!args || typeof args !== "object") return [];
+  if (tool === "apply_patch") {
+    return pathsInPatch(String(args.patchText ?? args.patch ?? ""));
+  }
+  const out = [];
+  const one = (v) => {
+    if (typeof v === "string" && v) out.push(v);
+  };
+  one(args.filePath);
+  one(args.path);
+  for (const c of Array.isArray(args.changes) ? args.changes : []) {
+    one(c?.filePath);
+    one(c?.path);
+  }
+  return out;
+}
 function deny(why, detail) {
   throw new Error(
     `${MARKER}: ${why}
@@ -301,24 +519,72 @@ function truncate(s, n = 200) {
   const one = s.replace(/\s+/g, " ").trim();
   return one.length > n ? `${one.slice(0, n)}...` : one;
 }
-var GuardPlugin = async ({ worktree }) => {
+var GuardPlugin = async ({ worktree, directory }) => {
+  const project = projectRoot(directory, worktree);
+  const telemetryDir = join3(project, ".space");
+  const refuse = (tool, rule, why, detail) => {
+    write(telemetryDir, { kind: "guard", tool, rule });
+    deny(why, detail);
+  };
   return {
     "tool.execute.before": async (input, output) => {
       try {
         if (input.tool === "bash") {
+          const raw = output.args?.workdir;
+          if (typeof raw === "string" && raw.trim()) {
+            const target = raw.startsWith("~") ? join3(homedir2(), raw.slice(1)) : resolve2(project, raw);
+            if (!insideRoot(target, project) && !insideRoot(target, tmpdir2())) {
+              refuse(
+                input.tool,
+                "command outside the project",
+                "command runs outside the project",
+                `the working directory is ${truncate(target)}, and this project's files are the ones you were asked to change`
+              );
+            }
+          }
           const hit = checkBash(String(output.args?.command ?? ""));
-          if (hit) deny(hit.name, `${hit.why}
+          if (hit) {
+            refuse(input.tool, hit.name, hit.name, `${hit.why}
   command: ${truncate(hit.segment)}`);
+          }
+          const command = String(output.args?.command ?? "");
+          const denied = checkDenied(command);
+          if (denied) {
+            refuse(
+              input.tool,
+              `denied command (${denied.pattern})`,
+              "denied command",
+              `this command matches \`${denied.pattern}\`, which the kit never allows.
+  command: ${truncate(denied.segment)}`
+            );
+          }
           return;
         }
-        if (input.tool === "write" || input.tool === "edit" || input.tool === "patch") {
-          const target = String(output.args?.filePath ?? output.args?.path ?? "") || String(output.args?.changes?.[0]?.filePath ?? "");
-          const hit = checkWrite(target, void 0, worktree);
-          if (hit) deny(hit.name, `${hit.why}
+        if (WRITE_TOOLS.has(input.tool)) {
+          const targets = writeTargets(input.tool, output.args);
+          if (!targets.length) {
+            refuse(
+              input.tool,
+              "unknown write target",
+              "cannot tell what this write touches",
+              `the ${input.tool} tool's arguments name no file, so the scope of the write is unknown`
+            );
+          }
+          for (const target of targets) {
+            const hit = checkWrite(target, void 0, project);
+            if (hit) {
+              refuse(input.tool, hit.name, hit.name, `${hit.why}
   file: ${truncate(hit.segment)}`);
+            }
+          }
         }
       } catch (err) {
         if (err instanceof Error && err.message.startsWith(MARKER)) throw err;
+        write(telemetryDir, {
+          kind: "guard",
+          tool: input.tool,
+          rule: "guard failed closed"
+        });
         throw new Error(
           `${MARKER} (guard failed closed): ${err instanceof Error ? err.message : String(err)}`
         );
@@ -328,21 +594,22 @@ var GuardPlugin = async ({ worktree }) => {
 };
 
 // src/profile.js
-import { readFileSync, existsSync, readdirSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
+import { readFileSync, existsSync as existsSync3, readdirSync } from "node:fs";
+import { dirname as dirname2, join as join4, resolve as resolve3 } from "node:path";
+import { homedir as homedir3 } from "node:os";
 import { fileURLToPath } from "node:url";
-var HERE = dirname(fileURLToPath(import.meta.url));
+var HERE = dirname2(fileURLToPath(import.meta.url));
 function findRoot(start) {
   let dir = start;
-  for (let i = 0; i < 6; i++) {
-    if (existsSync(join(dir, "profiles"))) return dir;
-    const parent = dirname(dir);
+  for (let i = 0; i < 12; i++) {
+    if (existsSync3(join4(dir, "profiles"))) return dir;
+    const parent = dirname2(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return resolve(start, "..");
+  return resolve3(start, "..");
 }
-var ROOT = findRoot(resolve(HERE, ".."));
+var ROOT = findRoot(resolve3(HERE, ".."));
 var ProfileError = class extends Error {
 };
 var LANE_NAMES = [
@@ -357,14 +624,20 @@ var LANE_NAMES = [
   "sweep",
   "longform"
 ];
-var RETENTION_SEVERITY = ["zero-retention", "retained", "unknown", "may-train"];
+var RETENTION_SEVERITY = ["zero-retention", "retained", "may-train", "unknown"];
+function retentionSeverity(level) {
+  return RETENTION_SEVERITY.indexOf(
+    /** @type {Retention} */
+    level
+  );
+}
 function profileDirs() {
-  return [join(ROOT, "profiles")];
+  return [process.env.OPENCODE_HARNESS_PROFILES ?? join4(ROOT, "profiles")];
 }
 function profilePath(id) {
   for (const dir of profileDirs()) {
-    const full = join(dir, `${id}.json`);
-    if (existsSync(full)) return full;
+    const full = join4(dir, `${id}.json`);
+    if (existsSync3(full)) return full;
   }
   return null;
 }
@@ -405,8 +678,8 @@ function normalize(p) {
 var laneCache = null;
 function loadLanes() {
   if (laneCache) return laneCache;
-  const file = join(ROOT, "lanes.json");
-  if (!existsSync(file)) {
+  const file = join4(ROOT, "lanes.json");
+  if (!existsSync3(file)) {
     throw new ProfileError(`lane table missing: ${file}`);
   }
   const parsed = JSON.parse(readFileSync(file, "utf8"));
@@ -425,15 +698,25 @@ function loadLanes() {
 function laneMeta(name) {
   return loadLanes()[name] ?? null;
 }
+var retentionCache = null;
 function loadRetention() {
-  const file = join(ROOT, "retention.yml");
-  if (!existsSync(file)) return {};
-  const out = (
+  if (retentionCache) return retentionCache;
+  const file = join4(ROOT, "retention.yml");
+  if (!existsSync3(file)) {
+    retentionCache = { models: {}, defaults: {} };
+    return retentionCache;
+  }
+  const models = (
     /** @type {Record<string, any>} */
     {}
   );
+  const defaults = (
+    /** @type {Record<string, string>} */
+    {}
+  );
   const lines = readFileSync(file, "utf8").split("\n");
   let current = null;
+  let inDefaults = false;
   let i = 0;
   while (i < lines.length) {
     const raw = lines[i];
@@ -443,10 +726,28 @@ function loadRetention() {
       i++;
       continue;
     }
+    if (indent === 0 && line === "defaults:") {
+      inDefaults = true;
+      current = null;
+      i++;
+      continue;
+    }
+    if (indent === 0 && line === "models:") {
+      inDefaults = false;
+      current = null;
+      i++;
+      continue;
+    }
+    if (inDefaults) {
+      const pair = line.match(/^([a-z-]+)\s*:\s*(\S+)\s*$/);
+      if (pair) defaults[pair[1]] = pair[2];
+      i++;
+      continue;
+    }
     if (indent === 2 && line.endsWith(":")) {
       const key = line.slice(0, -1).trim();
       current = key.includes("/") ? key : `opencode/${key}`;
-      out[current] = { retention: "unknown" };
+      models[current] = { retention: "unknown" };
       i++;
       continue;
     }
@@ -470,34 +771,41 @@ function loadRetention() {
           if (l.length - l.trimStart().length <= indent) break;
           parts.push(l.trim());
         }
-        out[current][name] = parts.join(" ").replace(/\s+/g, " ").trim();
+        models[current][name] = parts.join(" ").replace(/\s+/g, " ").trim();
         i = j;
         continue;
       }
-      out[current][name] = rest.replace(/^["']|["']$/g, "");
+      models[current][name] = rest.replace(/^["']|["']$/g, "");
       i++;
       continue;
     }
     i++;
   }
-  return out;
+  retentionCache = { models, defaults };
+  return retentionCache;
 }
 function retentionFor(id) {
-  const table = loadRetention();
+  const table = loadRetention().models;
   return table[id] ?? table[id.includes("/") ? id : `opencode/${id}`];
 }
-function modelRetention(model) {
-  const declared = retentionFor(model)?.retention ?? "unknown";
+function retentionOf(table, model) {
+  const fallback = table?.defaults?.unknown ?? "unknown";
+  const models = table?.models ?? {};
+  const record = models[model] ?? models[model.includes("/") ? model : `opencode/${model}`];
+  const declared = record?.retention ?? fallback;
   return (
     /** @type {Retention} */
     ["zero-retention", "retained", "may-train", "unknown"].includes(declared) ? declared : "unknown"
   );
 }
+function modelRetention(model) {
+  return retentionOf(loadRetention(), model);
+}
 function retentionAllowed(model, ceiling) {
   const level = modelRetention(model);
   if (level === "unknown") return false;
-  const max = RETENTION_SEVERITY.indexOf(ceiling);
-  const have = RETENTION_SEVERITY.indexOf(level);
+  const max = retentionSeverity(ceiling);
+  const have = retentionSeverity(level);
   if (max < 0) return false;
   return have <= max;
 }
@@ -518,6 +826,9 @@ function resolveLaneModel(p, role, opts = {}) {
     if (!retentionAllowed(candidate, ceiling)) continue;
     return { model: candidate, levels: levelsOfModel(candidate) };
   }
+  if (p.model && !unhealthy.has(p.model) && retentionAllowed(p.model, ceiling)) {
+    return { model: p.model, levels: levelsOfModel(p.model) };
+  }
   const fallback = resolveLaneChain(p, role)[0] ?? p.model;
   return { model: fallback, levels: levelsOfModel(fallback) };
 }
@@ -551,6 +862,7 @@ function resolveEffort(levels, requested) {
   if (!requested) return null;
   if (!levels || levels.length === 0) return null;
   if (levels.includes(requested)) return requested;
+  if (requested === "none") return null;
   const want = CANON.indexOf(requested);
   if (want < 0) {
     return levels[levels.length - 1] ?? null;
@@ -611,6 +923,29 @@ function validate(p, path = "<memory>") {
       );
     }
   }
+  if (p.prune) {
+    const prune = p.prune;
+    if (prune.keepRecentToolCalls !== void 0) {
+      if (!Number.isInteger(prune.keepRecentToolCalls) || prune.keepRecentToolCalls < 1) {
+        throw new ProfileError(
+          `${where}: prune.keepRecentToolCalls must be an integer of at least 1`
+        );
+      }
+    }
+    if (prune.keepRecentTurns !== void 0) {
+      if (!Number.isInteger(prune.keepRecentTurns) || prune.keepRecentTurns < 1) {
+        throw new ProfileError(
+          `${where}: prune.keepRecentTurns must be an integer of at least 1`
+        );
+      }
+    }
+    if (prune.keepUserMessages !== void 0 && typeof prune.keepUserMessages !== "boolean") {
+      throw new ProfileError(`${where}: prune.keepUserMessages must be a boolean`);
+    }
+    if (prune.enabled !== void 0 && typeof prune.enabled !== "boolean") {
+      throw new ProfileError(`${where}: prune.enabled must be a boolean`);
+    }
+  }
   for (const [role, rm] of Object.entries(p.roleModels ?? {})) {
     if (!LANE_NAMES.includes(role)) {
       throw new ProfileError(
@@ -625,9 +960,9 @@ function validate(p, path = "<memory>") {
     if (!rm?.model || typeof rm.model !== "string") {
       throw new ProfileError(`${where}: roleModels.${role} needs a model`);
     }
-    if (rm.levels !== void 0 && !Array.isArray(rm.levels)) {
+    if (rm.levels !== void 0) {
       throw new ProfileError(
-        `${where}: roleModels.${role}.levels must be an array`
+        `${where}: roleModels.${role}.levels is not read by anything - the lane takes its levels from the model it runs on. Remove it.`
       );
     }
     if (rm.chain !== void 0) {
@@ -647,6 +982,11 @@ function validate(p, path = "<memory>") {
             `${where}: roleModels.${role}.chain names ${rung}, which has no retention.yml entry`
           );
         }
+        if (!profileExists(rung)) {
+          throw new ProfileError(
+            `${where}: roleModels.${role}.chain names ${rung}, which has no profile in this directory`
+          );
+        }
       }
     }
     if (!retentionFor(rm.model)) {
@@ -654,8 +994,38 @@ function validate(p, path = "<memory>") {
         `${where}: roleModels.${role} names ${rm.model}, which has no retention.yml entry`
       );
     }
+    if (!profileExists(rm.model)) {
+      throw new ProfileError(
+        `${where}: roleModels.${role} names ${rm.model}, which has no profile in this directory`
+      );
+    }
+  }
+  if (p.utility) {
+    if (typeof p.utility.model !== "string" || !p.utility.model) {
+      throw new ProfileError(`${where}: utility.model must be a model id`);
+    }
+    const reachable = /* @__PURE__ */ new Set([p.model]);
+    for (const rm of Object.values(p.roleModels ?? {})) {
+      if (rm?.model) reachable.add(rm.model);
+      for (const rung of rm?.chain ?? []) reachable.add(rung);
+    }
+    if (!reachable.has(p.utility.model)) {
+      throw new ProfileError(
+        `${where}: utility.model is ${p.utility.model}, which this profile does not resolve to (it has ${[...reachable].join(", ")})`
+      );
+    }
+  }
+  for (const id of p.fallback ?? []) {
+    if (!profileExists(id)) {
+      throw new ProfileError(
+        `${where}: fallback names ${id}, which has no profile in this directory`
+      );
+    }
   }
 }
+function profileExists(id) {
+  return profilePath(id) !== null;
+}
 function inputCap(p, opts = {}) {
   let cap = p.limits.input ?? p.limits.context;
   for (const s of roleSplitModels(p, opts)) {
@@ -684,10 +1054,10 @@ function roleSplitModels(p, opts = {}) {
   });
 }
 function configDir() {
-  return process.env.OPENCODE_CONFIG_DIR ?? join(process.env.HOME ?? "", ".config", "opencode");
+  return process.env.OPENCODE_CONFIG_DIR ?? join4(homedir3(), ".config", "opencode");
 }
 function configFilePath() {
-  return join(configDir(), "opencode.jsonc");
+  return join4(configDir(), "opencode.jsonc");
 }
 function parseJsonc(text) {
   let out = "";
@@ -762,7 +1132,7 @@ function profileIdFromConfig() {
   const fromEnv = process.env.OPENCODE_HARNESS_PROFILE;
   if (fromEnv) return fromEnv.trim() || null;
   const file = configFilePath();
-  if (!existsSync(file)) return null;
+  if (!existsSync3(file)) return null;
   try {
     const parsed = parseJsonc(readFileSync(file, "utf8"));
     const harness = parsed?.harness;
@@ -777,18 +1147,16 @@ function profileIdFromConfig() {
 }
 
 // src/prune.ts
-import { readFileSync as readFileSync2, existsSync as existsSync2 } from "node:fs";
-import { join as join2 } from "node:path";
+import { readFileSync as readFileSync2, existsSync as existsSync4 } from "node:fs";
+import { join as join5 } from "node:path";
 function activeProfileId(worktree) {
-  const candidates = [
-    process.env.OPENCODE_HARNESS_PROFILE,
-    join2(worktree, ".space", "active"),
-    join2(ROOT, "profiles", ".active")
-  ];
+  const fromEnv = process.env.OPENCODE_HARNESS_PROFILE;
+  if (fromEnv && fromEnv.trim()) return fromEnv.trim();
+  const candidates = [join5(worktree, ".space", "active")];
   for (const f of candidates) {
     if (!f) continue;
     try {
-      if (existsSync2(f)) {
+      if (existsSync4(f)) {
         const v = readFileSync2(f, "utf8").trim();
         if (v) return v;
       }
@@ -797,6 +1165,7 @@ function activeProfileId(worktree) {
   }
   return null;
 }
+var REASONING_STUB = "[reasoning] dropped from context - it was from an earlier turn and is stale.";
 function sizeOf(part) {
   if (typeof part?.text === "string") return part.text.length;
   if (typeof part?.state?.output === "string") return part.state.output.length;
@@ -811,7 +1180,7 @@ function stub(part) {
     const status = state.status ?? "done";
     let tail = "";
     const out = String(state.output ?? "");
-    const m = out.match(/(passed|failed|error|Error|ok|OK|\d+ (?:passed|failed))/g);
+    const m = out.match(/\b(?:\d+\s+(?:passed|failed)|passed|failed|error|ok)\b/gi);
     if (m && m.length) tail = `, ${m[m.length - 1]}`;
     return `[${tool}] ${cmd} -> ${status}${tail} | full output was pruned from context; re-run the command if you need it`;
   }
@@ -821,24 +1190,40 @@ function stub(part) {
   }
   return `[${tool}] result pruned from context (${state.status ?? "done"}); re-run if you need it`;
 }
-var PrunePlugin = async ({ worktree, $ }) => {
-  let profile = null;
-  try {
-    const id = activeProfileId(worktree);
-    if (id) profile = loadProfile(id);
-  } catch {
-    profile = null;
-  }
-  if (!profile?.prune?.enabled) {
-    return {};
-  }
-  const keepCalls = profile.prune.keepRecentToolCalls ?? 6;
-  const keepTurns = profile.prune.keepRecentTurns ?? 3;
-  const keepUsers = profile.prune.keepUserMessages ?? true;
-  const threshold = pruneThreshold(profile);
+var PrunePlugin = async ({ worktree, directory }) => {
+  const project = projectRoot(directory, worktree);
+  const DISABLED = {
+    profile: null,
+    keepCalls: 0,
+    keepTurns: 0,
+    keepUsers: true,
+    threshold: 0
+  };
+  let cached = null;
+  const resolve4 = () => {
+    if (cached) return cached;
+    let profile = null;
+    try {
+      const id = activeProfileId(project);
+      if (id) profile = loadProfile(id);
+    } catch {
+      profile = null;
+    }
+    if (!profile?.prune?.enabled) return DISABLED;
+    cached = {
+      profile,
+      keepCalls: profile.prune.keepRecentToolCalls ?? 6,
+      keepTurns: profile.prune.keepRecentTurns ?? 3,
+      keepUsers: profile.prune.keepUserMessages ?? true,
+      threshold: pruneThreshold(profile)
+    };
+    return cached;
+  };
   return {
     "experimental.chat.messages.transform": async (_input, output) => {
       try {
+        const { profile, keepCalls, keepTurns, keepUsers, threshold } = resolve4();
+        if (!profile) return;
         const messages = output.messages;
         if (!Array.isArray(messages) || messages.length === 0) return;
         const floor = Math.max(0, messages.length - 1 - keepTurns);
@@ -883,10 +1268,12 @@ var PrunePlugin = async ({ worktree, $ }) => {
                 stats.bytesAfter += size;
                 stats.kept++;
                 break;
-              case "reasoning":
-                stats.bytesAfter += Math.min(size, 200);
+              case "reasoning": {
+                part.text = REASONING_STUB;
+                stats.bytesAfter += sizeOf(part);
                 stats.stubbed++;
                 break;
+              }
               case "tool": {
                 const state = part.state;
                 if (state?.status !== "completed") {
@@ -918,7 +1305,7 @@ var PrunePlugin = async ({ worktree, $ }) => {
         }
         if (stats.stubbed > 0) {
           const saved = Math.max(0, stats.bytesBefore - stats.bytesAfter);
-          await logPrune(profile.id, {
+          await logPrune(project, profile.id, {
             ...stats,
             saved,
             threshold
@@ -932,19 +1319,19 @@ var PrunePlugin = async ({ worktree, $ }) => {
     }
   };
 };
-async function logPrune(profileId, stats) {
-  const dir = join2(process.cwd(), ".space");
+async function logPrune(worktree, profileId, stats) {
+  const dir = join5(worktree, ".space");
   try {
     const { mkdir, appendFile } = await import("node:fs/promises");
     await mkdir(dir, { recursive: true });
     await appendFile(
-      join2(dir, "prune.jsonl"),
+      join5(dir, "prune.jsonl"),
       JSON.stringify({
         t: (/* @__PURE__ */ new Date()).toISOString(),
         profile: profileId,
         stubbed: stats.stubbed,
         kept: stats.kept,
-        savedBytes: stats.saved,
+        savedChars: stats.saved,
         threshold: stats.threshold
       }) + "\n"
     );
@@ -952,34 +1339,56 @@ async function logPrune(profileId, stats) {
   }
 }
 
-// src/router.ts
-import { readFileSync as readFileSync3, writeFileSync, mkdirSync } from "node:fs";
-import { join as join3 } from "node:path";
-function healthPath(worktree) {
-  return join3(worktree, ".space", "health.json");
+// src/safe.ts
+function safeStringify(value) {
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch {
+    try {
+      return String(value);
+    } catch {
+      return "[unstringifiable]";
+    }
+  }
 }
-function readHealth(worktree) {
+
+// src/config.js
+function utilityModel(p) {
+  const u = p?.utility;
+  if (!u || typeof u.model !== "string" || !u.model) return null;
+  return `${p.provider ?? "opencode"}/${u.model}`;
+}
+
+// src/health.js
+import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync } from "node:fs";
+import { join as join6 } from "node:path";
+function healthPath(dir) {
+  return join6(dir, ".space", "health.json");
+}
+function readHealth(dir) {
   try {
-    return JSON.parse(readFileSync3(healthPath(worktree), "utf8"));
+    return JSON.parse(readFileSync3(healthPath(dir), "utf8"));
   } catch {
     return { unhealthy: {} };
   }
 }
-function writeHealth(worktree, h) {
+function writeHealth(dir, health) {
   try {
-    mkdirSync(join3(worktree, ".space"), { recursive: true });
-    writeFileSync(healthPath(worktree), JSON.stringify(h, null, 2));
+    if (!existsSync5(join6(dir, ".space"))) mkdirSync2(join6(dir, ".space"), { recursive: true });
+    writeFileSync(healthPath(dir), JSON.stringify(health, null, 2));
   } catch {
   }
 }
-function unhealthyModels(worktree) {
-  const health = readHealth(worktree);
+function unhealthyModels(dir) {
+  const health = readHealth(dir);
   const out = /* @__PURE__ */ new Set();
   for (const key of Object.keys(health.unhealthy ?? {})) {
     out.add(key.includes("/") ? key.slice(key.indexOf("/") + 1) : key);
   }
   return out;
 }
+
+// src/router.ts
 var SPENT = [
   /FreeUsageLimitError/i,
   /rate[_ -]?limit/i,
@@ -994,7 +1403,8 @@ function classify(text) {
   return null;
 }
 var WARN_TEXT = "[opencode-harness-kit] This session's model route is rate limited or withdrawn. No plugin can swap a live session's model, so stop retrying and ask the human to start a new session. Run `oc-harness list` to see the lanes and their chains, or `oc-harness doctor` to check whether the profile still matches live metadata.";
-var RouterPlugin = async ({ worktree }) => {
+var RouterPlugin = async ({ worktree, directory }) => {
+  const project = projectRoot(directory, worktree);
   let failedSessions = 0;
   let warned = false;
   return {
@@ -1002,8 +1412,8 @@ var RouterPlugin = async ({ worktree }) => {
     config: async (config) => {
       try {
         const cfg = config;
-        const health = readHealth(worktree);
-        const unhealthy = unhealthyModels(worktree);
+        const health = readHealth(project);
+        const unhealthy = unhealthyModels(project);
         const activeId = cfg.harness?.profile ?? profileIdFromConfig();
         if (!activeId) return;
         const id = activeId;
@@ -1017,7 +1427,6 @@ var RouterPlugin = async ({ worktree }) => {
         if (health.unhealthy?.[baseKey]) {
           const queue = [id, ...profile.fallback ?? []];
           for (const candidate of queue) {
-            if (health.unhealthy?.[`opencode/${candidate}`]) continue;
             let fallback;
             try {
               fallback = loadProfile(candidate);
@@ -1036,7 +1445,7 @@ var RouterPlugin = async ({ worktree }) => {
               threshold: fleet ? pruneThreshold(profile) : void 0
             });
             health.active = candidate;
-            writeHealth(worktree, health);
+            writeHealth(project, health);
             break;
           }
         }
@@ -1063,16 +1472,16 @@ var RouterPlugin = async ({ worktree }) => {
       const e = event;
       const type = e?.type;
       if (!type) return;
-      const text = JSON.stringify(e);
+      const text = safeStringify(e);
       const reason = classify(text);
       if (!reason) return;
       const modelID = e.properties?.modelID ?? e.properties?.model ?? e.properties?.modelID;
       const key = modelID ? `opencode/${modelID}` : void 0;
       if (!key) return;
-      const health = readHealth(worktree);
+      const health = readHealth(project);
       if (health.unhealthy[key]) return;
       health.unhealthy[key] = { at: (/* @__PURE__ */ new Date()).toISOString(), reason };
-      writeHealth(worktree, health);
+      writeHealth(project, health);
       failedSessions++;
     },
     "chat.message": async (input, output) => {
@@ -1087,7 +1496,7 @@ var RouterPlugin = async ({ worktree }) => {
 ${WARN_TEXT}`;
         return;
       }
-      writeHealth(worktree, readHealth(worktree));
+      writeHealth(project, readHealth(project));
     }
   };
 };
@@ -1098,7 +1507,7 @@ function applySessionModel(cfg, profile, opts = {}) {
   try {
     const model = `${profile.provider}/${profile.model}`;
     cfg.model = model;
-    cfg.small_model = model;
+    cfg.small_model = utilityModel(profile) ?? model;
     const variant = profile.effort?.default;
     if (profile.effort?.levels?.length && variant) cfg.variant = variant;
     else delete cfg.variant;
@@ -1127,31 +1536,9 @@ function applySessionModel(cfg, profile, opts = {}) {
 }
 
 // src/telemetry.ts
-import { appendFileSync, mkdirSync as mkdirSync2, existsSync as existsSync4, statSync, renameSync } from "node:fs";
-import { join as join4 } from "node:path";
-var MAX_BYTES = 4 * 1024 * 1024;
-function logPath(dir) {
-  return join4(dir, "telemetry.jsonl");
-}
-function rotate(file) {
-  try {
-    if (existsSync4(file) && statSync(file).size > MAX_BYTES) {
-      renameSync(file, `${file}.1`);
-    }
-  } catch {
-  }
-}
-function write(dir, record) {
-  try {
-    if (!existsSync4(dir)) mkdirSync2(dir, { recursive: true });
-    const file = logPath(dir);
-    rotate(file);
-    appendFileSync(file, JSON.stringify({ t: (/* @__PURE__ */ new Date()).toISOString(), ...record }) + "\n");
-  } catch {
-  }
-}
-var TelemetryPlugin = async ({ worktree }) => {
-  const dir = join4(worktree, ".space");
+import { join as join7 } from "node:path";
+var TelemetryPlugin = async ({ worktree, directory }) => {
+  const dir = join7(projectRoot(directory, worktree), ".space");
   const started = Date.now();
   const opened = /* @__PURE__ */ new Set();
   const closed = /* @__PURE__ */ new Set();
@@ -1159,7 +1546,7 @@ var TelemetryPlugin = async ({ worktree }) => {
     event: async ({ event }) => {
       const type = event?.type;
       if (typeof type !== "string") return;
-      if (/error|rate|limit|quota/i.test(type)) {
+      if (/(^|[._-])(error|errors|rate|limit|limits|quota)([._-]|$)/i.test(type)) {
         write(dir, { kind: "provider-event", type, detail: truncate2(safeStringify(event)) });
         return;
       }
@@ -1178,14 +1565,9 @@ var TelemetryPlugin = async ({ worktree }) => {
       }
     },
     "tool.execute.after": async (input, output) => {
-      const text = typeof output?.output === "string" ? output.output : "";
-      if (text.includes("[opencode-harness-kit] blocked")) {
-        write(dir, { kind: "guard", tool: input.tool, rule: extractRule(text) });
-        return;
-      }
       const command = String(input.args?.command ?? "");
-      if (input.tool === "bash" && /git push|rm -rf|chmod 777/.test(command)) {
-        write(dir, { kind: "guard-attempt", tool: input.tool, command: truncate2(command) });
+      if (input.tool === "bash" && ASK_GATED.some((p) => p.test(command))) {
+        write(dir, { kind: "guard-allowed", tool: input.tool, command: truncate2(command) });
       }
     },
     dispose: async () => {
@@ -1207,28 +1589,22 @@ function laneOf(event) {
   const completed = typeof time.completed === "number" ? time.completed : void 0;
   const ms = created !== void 0 && completed !== void 0 ? completed - created : void 0;
   if (!id || !agent) return null;
+  const tokens = info.tokens ?? {};
+  const ctx = typeof tokens.input === "number" ? tokens.input + (typeof tokens.cache?.read === "number" ? tokens.cache.read : 0) : void 0;
+  const reasoning = typeof tokens.reasoning === "number" ? tokens.reasoning : void 0;
   return {
     id,
     agent,
     model: typeof modelId === "string" ? modelId : void 0,
     provider: typeof providerId === "string" ? providerId : void 0,
-    ms: typeof ms === "number" && ms >= 0 ? ms : void 0
+    ms: typeof ms === "number" && ms >= 0 ? ms : void 0,
+    ctx: typeof ctx === "number" ? ctx : void 0,
+    reasoning
   };
 }
-function extractRule(output) {
-  const m = output.match(/blocked:\s*([^\n]+)/);
-  return m ? m[1].trim() : "unknown";
-}
 function truncate2(s, n = 300) {
   return s.length > n ? `${s.slice(0, n)}...` : s;
 }
-function safeStringify(value) {
-  try {
-    return JSON.stringify(value) ?? String(value);
-  } catch {
-    return String(value);
-  }
-}
 
 // src/effort.js
 function planEffort(profileId, opts = {}) {
@@ -1242,8 +1618,15 @@ 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) {
+      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}.`);
     }
   }
@@ -1280,8 +1663,7 @@ function applyEffort(config, result, opts = {}) {
   }
   cfg.harness = {
     ...cfg.harness ?? {},
-    profile: result.profileId,
-    ...opts.fallbackProfileId ? { fallback: opts.fallbackProfileId } : {}
+    profile: result.profileId
   };
   return config;
 }
@@ -1311,14 +1693,15 @@ var HarnessPlugin = async (ctx, options) => {
     if (routerConfig) await routerConfig(config);
     const id = opts.profile ?? config?.harness?.profile ?? profileIdFromConfig();
     if (!id) return;
+    const project = projectRoot(ctx.directory, ctx.worktree);
     try {
       const sessionModel = typeof config?.harness?.sessionModel === "string" ? config.harness.sessionModel : void 0;
-      applyEffort(config, planEffort(id, { unhealthy: unhealthyModels(ctx.worktree) }), {
+      applyEffort(config, planEffort(id, { unhealthy: unhealthyModels(project) }), {
         sessionModel
       });
-      const dir = join5(ctx.worktree, ".space");
+      const dir = join8(project, ".space");
       mkdirSync3(dir, { recursive: true });
-      writeFileSync2(join5(dir, "active"), `${id}
+      writeFileSync2(join8(dir, "active"), `${id}
 `);
     } catch {
     }