opencode-harness-kit 0.1.0 → 0.2.1

package/dist/index.js

@@ -140,26 +140,6 @@ function tokenize(segment) {
 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 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 (; ; ) {
@@ -190,26 +170,6 @@ 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) {
@@ -240,21 +200,9 @@ var BASH_RULES = [
     test: /\b(curl|wget)\b[^|]*\|\s*(sudo\s+)?(sh|bash|zsh|python[0-9.]*)\b/i,
     why: "downloads and executes a script in one step"
   },
-  {
-    name: "git push with force",
-    scope: "segment",
-    // A dry run publishes nothing, so it is not the thing being gated.
-    check: (seg) => gitSubcommand(seg) === "push" && tokenize(seg).some((w) => w === "--force" || w === "-f" || w.startsWith("--force")),
-    why: "overwrites published history"
-  },
-  {
-    name: "git push",
-    scope: "segment",
-    // Flags are matched as whole words: a `-f` in `my-feature-f` is a branch
-    // name, not a force flag.
-    check: (seg) => gitSubcommand(seg) === "push" && !tokenize(seg).some((w) => w === "--dry-run" || w === "-n"),
-    why: "publishing is a human decision"
-  },
+  // `git push` is ask-gated via permissions (`*` ask in the generated
+  // config), not guard-blocked. Publishing needs human approval, but the
+  // guard lets it through so opencode can prompt first.
   {
     name: "recursive delete",
     scope: "segment",
@@ -453,6 +401,31 @@ function validate(p, path = "<memory>") {
       `${where}: effort.reserveShare must be between 0 and 0.5`
     );
   }
+  for (const [role, rm] of Object.entries(p.roleModels ?? {})) {
+    if (!SPLITTABLE_ROLES.includes(role)) {
+      throw new ProfileError(
+        `${where}: roleModels.${role} is not one of ${SPLITTABLE_ROLES.join(", ")}`
+      );
+    }
+    if (!(role in (p.roles ?? {}))) {
+      throw new ProfileError(
+        `${where}: roleModels.${role} has no matching entry in roles, so it would never apply`
+      );
+    }
+    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)) {
+      throw new ProfileError(
+        `${where}: roleModels.${role}.levels must be an array`
+      );
+    }
+    if (!retentionFor(rm.model)) {
+      throw new ProfileError(
+        `${where}: roleModels.${role} names ${rm.model}, which has no retention.yml entry`
+      );
+    }
+  }
 }
 var CANON = ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
 function resolveEffort(levels, requested) {
@@ -476,42 +449,202 @@ function resolveEffort(levels, requested) {
   }
   return best ?? levels[levels.length - 1] ?? null;
 }
+function resolveRoleModel(p, role) {
+  const rm = p.roleModels?.[role];
+  if (!rm) return null;
+  return { model: rm.model, levels: rm.levels ?? [] };
+}
+function levelsForRole(p, role) {
+  const rm = resolveRoleModel(p, role);
+  if (rm) return rm.levels;
+  return p.effort?.levels ?? [];
+}
 function resolveRoles(p) {
-  const levels = p.effort?.levels ?? [];
   const out = (
     /** @type {Record<string, string | null>} */
     {}
   );
   for (const [role, want] of Object.entries(p.roles ?? {})) {
-    out[role] = resolveEffort(levels, want);
+    out[role] = resolveEffort(levelsForRole(p, role), want);
   }
   return out;
 }
 function resolveDefaultVariant(p) {
   return resolveEffort(p.effort?.levels ?? [], p.effort?.default ?? null);
 }
+var SPLITTABLE_ROLES = ["plan", "build", "reviewer", "locate", "verify"];
+function inputCap(p) {
+  let cap = p.limits.input ?? p.limits.context;
+  for (const s of roleSplitModels(p)) {
+    const other = s.limits?.input ?? s.limits?.context;
+    if (typeof other === "number" && other > cap) cap = other;
+  }
+  return cap;
+}
 function reservedTokens(p) {
-  const input = p.limits.input ?? p.limits.context;
   const share = p.effort?.reserveShare ?? 0.12;
-  return Math.max(8e3, Math.round(input * share));
+  return Math.max(8e3, Math.round(inputCap(p) * share));
 }
 function pruneThreshold(p) {
-  return (p.limits.input ?? p.limits.context) - reservedTokens(p);
+  return inputCap(p) - reservedTokens(p);
+}
+function loadRetention() {
+  const file = join(ROOT, "retention.yml");
+  if (!existsSync(file)) return {};
+  const out = (
+    /** @type {Record<string, any>} */
+    {}
+  );
+  const lines = readFileSync(file, "utf8").split("\n");
+  let current = null;
+  let i = 0;
+  while (i < lines.length) {
+    const raw = lines[i];
+    const line = raw.trim();
+    const indent = raw.length - raw.trimStart().length;
+    if (!line || line.startsWith("#")) {
+      i++;
+      continue;
+    }
+    if (indent === 2 && line.endsWith(":")) {
+      const key = line.slice(0, -1).trim();
+      current = key.includes("/") ? key : `opencode/${key}`;
+      out[current] = { retention: "unknown" };
+      i++;
+      continue;
+    }
+    if (!current) {
+      i++;
+      continue;
+    }
+    const field = line.match(/^(retention|verified|source|note):\s*(.*)$/);
+    if (field) {
+      const name = field[1];
+      const rest = field[2].trim();
+      if (/^[>|][-+]?$/.test(rest)) {
+        const parts = [];
+        let j = i + 1;
+        for (; j < lines.length; j++) {
+          const l = lines[j];
+          if (!l.trim()) {
+            parts.push("");
+            continue;
+          }
+          if (l.length - l.trimStart().length <= indent) break;
+          parts.push(l.trim());
+        }
+        out[current][name] = parts.join(" ").replace(/\s+/g, " ").trim();
+        i = j;
+        continue;
+      }
+      out[current][name] = rest.replace(/^["']|["']$/g, "");
+      i++;
+      continue;
+    }
+    i++;
+  }
+  return out;
+}
+function retentionFor(id) {
+  const table = loadRetention();
+  return table[id] ?? table[id.includes("/") ? id : `opencode/${id}`];
+}
+function roleSplitModels(p) {
+  return Object.entries(p.roleModels ?? {}).map(([role, rm]) => {
+    let limits = null;
+    try {
+      limits = loadProfile(rm.model)?.limits ?? null;
+    } catch {
+      limits = null;
+    }
+    return { role, model: rm.model, levels: rm.levels ?? [], limits };
+  });
 }
 function configFilePath() {
   const dir = process.env.OPENCODE_CONFIG_DIR ?? join(process.env.HOME ?? "", ".config", "opencode");
   return join(dir, "opencode.jsonc");
 }
+function parseJsonc(text) {
+  let out = "";
+  let i = 0;
+  let inString = false;
+  let escaped = false;
+  let pendingComma = false;
+  const n = text.length;
+  while (i < n) {
+    const ch = text[i];
+    if (inString) {
+      out += ch;
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      i++;
+      continue;
+    }
+    if (ch === '"') {
+      if (pendingComma) {
+        out += ",";
+        pendingComma = false;
+      }
+      out += ch;
+      inString = true;
+      i++;
+      continue;
+    }
+    if (ch === "/" && text[i + 1] === "/") {
+      while (i < n && text[i] !== "\n") i++;
+      continue;
+    }
+    if (ch === "/" && text[i + 1] === "*") {
+      i += 2;
+      while (i < n && !(text[i] === "*" && text[i + 1] === "/")) i++;
+      i += 2;
+      continue;
+    }
+    if (ch === ",") {
+      if (pendingComma) return null;
+      pendingComma = true;
+      i++;
+      continue;
+    }
+    if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") {
+      out += ch;
+      i++;
+      continue;
+    }
+    if (ch === "}" || ch === "]") {
+      pendingComma = false;
+      out += ch;
+      i++;
+      continue;
+    }
+    if (pendingComma) {
+      out += ",";
+      pendingComma = false;
+    }
+    out += ch;
+    i++;
+  }
+  try {
+    const parsed = JSON.parse(out);
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    if (!out.trim()) return {};
+    return null;
+  }
+}
 function profileIdFromConfig() {
   const fromEnv = process.env.OPENCODE_HARNESS_PROFILE;
   if (fromEnv) return fromEnv.trim() || null;
   const file = configFilePath();
   if (!existsSync(file)) return null;
   try {
-    const text = readFileSync(file, "utf8");
-    const json = text.slice(text.indexOf("{"));
-    const parsed = JSON.parse(json);
-    const id = parsed?.harness?.profile;
+    const parsed = parseJsonc(readFileSync(file, "utf8"));
+    const harness = parsed?.harness;
+    const id = harness && typeof harness === "object" ? (
+      /** @type {{profile?: unknown}} */
+      harness.profile
+    ) : null;
     return typeof id === "string" && id ? id : null;
   } catch {
     return null;

package/package.json

@@ -1,11 +1,15 @@
 {
   "name": "opencode-harness-kit",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Model-agnostic harness kit for OpenCode: capability profiles, role-based reasoning effort, context pruning, and measured baselines.",
   "license": "MIT",
+  "homepage": "https://github.com/pham-canh/space-harness#readme",
   "repository": {
     "type": "git",
-    "url": "https://github.com/crytobot459/space-harness.git"
+    "url": "git+https://github.com/pham-canh/space-harness.git"
+  },
+  "bugs": {
+    "url": "https://github.com/pham-canh/space-harness/issues"
   },
   "type": "module",
   "main": "./dist/index.js",
@@ -33,7 +37,7 @@
     "GLOBAL.md",
     "agents/",
     "skills/",
-    "docs/",
+    "docs/*.md",
     "README.md",
     "LICENSE"
   ],
@@ -71,9 +75,7 @@
   "devDependencies": {
     "@opencode-ai/plugin": "^1.18.31",
     "@types/node": "^22.0.0",
+    "esbuild": "^0.28.2",
     "typescript": "^5.6.0"
-  },
-  "dependencies": {
-    "esbuild": "^0.28.2"
   }
 }

package/profiles/index.json

@@ -2,6 +2,24 @@
   "$comment": "Profiles verified against live provider metadata. `retention` must come from retention.yml; a model missing there cannot enter this list.",
   "default": "space-bunny-free",
   "profiles": [
+    {
+      "id": "muse-split-free",
+      "file": "profiles/muse-split-free.json",
+      "title": "Muse Spark 1.3 (heavy) + Space Bunny Free (bulk output)",
+      "retention": "may-train",
+      "free": true,
+      "topEffort": "max",
+      "context": 1048576,
+      "default": false,
+      "split": {
+        "plan": "muse-spark-1.3-contributor-free",
+        "build": "muse-spark-1.3-contributor-free",
+        "reviewer": "muse-spark-1.3-contributor-free",
+        "locate": "space-bunny-free",
+        "verify": "space-bunny-free"
+      },
+      "note": "Retention here is the effective one: three roles run on Muse Spark, so the file is may-train even though the base model is zero-retention."
+    },
     {
       "id": "space-bunny-free",
       "file": "profiles/space-bunny-free.json",

package/profiles/muse-split-free.json

@@ -0,0 +1,64 @@
+{
+  "$comment": "Split profile. The heavy reasoning roles run on Muse Spark 1.3 because it is the strongest free model on Zen by a wide margin (Terminal-Bench 2.1 88.8% vs Nemotron 3 Ultra's 56.4%, DeepSWE v1.1 75.4%). The bulk-output roles stay on Space Bunny because its 524,288-token output cap is 4x Muse Spark's 131,072, and scaffolding or migrating many files is where that ceiling is actually felt. `retention` below describes the BASE model only; the config header prints the effective retention, which is may-train because three roles run on Muse Spark.",
+  "id": "muse-split-free",
+  "title": "Muse Spark 1.3 (heavy) + Space Bunny Free (bulk output)",
+  "provider": "opencode",
+  "model": "space-bunny-free",
+  "family": null,
+  "verified": "2026-10-07",
+  "retention": "zero-retention",
+  "notes": "Opt-in split, not a default. Muse Spark is a Meta contributor-tier free endpoint: its provider may train on your prompts and completions. Three of the five roles are therefore may-train even though the base model is zero-retention. Install it only for public or throwaway repositories. Effort requests below are resolved against each role's own model, so plan and reviewer ask for `max` and land on `xhigh`, which is the top Muse Spark offers.",
+  "limits": {
+    "context": 1048576,
+    "input": 524288,
+    "output": 524288
+  },
+  "supports": {
+    "reasoning": true,
+    "temperature": false,
+    "toolCall": true,
+    "structuredOutput": false,
+    "attachment": true
+  },
+  "effort": {
+    "levels": ["low", "medium", "high", "xhigh", "max"],
+    "default": "max",
+    "reserveShare": 0.12
+  },
+  "roles": {
+    "plan": "max",
+    "build": "high",
+    "reviewer": "max",
+    "locate": "low",
+    "verify": "low"
+  },
+  "roleModels": {
+    "plan": {
+      "model": "muse-spark-1.3-contributor-free",
+      "levels": ["minimal", "low", "medium", "high", "xhigh"]
+    },
+    "build": {
+      "model": "muse-spark-1.3-contributor-free",
+      "levels": ["minimal", "low", "medium", "high", "xhigh"]
+    },
+    "reviewer": {
+      "model": "muse-spark-1.3-contributor-free",
+      "levels": ["minimal", "low", "medium", "high", "xhigh"]
+    },
+    "locate": {
+      "model": "space-bunny-free",
+      "levels": ["low", "medium", "high", "xhigh", "max"]
+    },
+    "verify": {
+      "model": "space-bunny-free",
+      "levels": ["low", "medium", "high", "xhigh", "max"]
+    }
+  },
+  "prune": {
+    "enabled": true,
+    "keepRecentToolCalls": 6,
+    "keepRecentTurns": 3,
+    "keepUserMessages": true
+  },
+  "fallback": ["x-preview-f-free", "longcat-2.5-preview-free", "deepseek-v4-flash-free"]
+}

package/profiles/schema.json

@@ -90,6 +90,18 @@
         "verify": { "$ref": "#/definitions/effortRequest" }
       }
     },
+    "roleModels": {
+      "type": "object",
+      "description": "Model per agent role, for a profile that splits the heavy reasoning roles onto a stronger model while the bulk-output roles stay on a high-output one. `model` remains the base: roles not named here, the top-level `model`, and `small_model` all resolve to it.",
+      "additionalProperties": false,
+      "properties": {
+        "plan": { "$ref": "#/definitions/roleModel" },
+        "build": { "$ref": "#/definitions/roleModel" },
+        "reviewer": { "$ref": "#/definitions/roleModel" },
+        "locate": { "$ref": "#/definitions/roleModel" },
+        "verify": { "$ref": "#/definitions/roleModel" }
+      }
+    },
     "prune": {
       "type": "object",
       "additionalProperties": false,
@@ -122,6 +134,23 @@
     }
   },
   "definitions": {
+    "roleModel": {
+      "type": "object",
+      "description": "A model for one role, plus the effort levels that model actually offers. Required when the model differs from the base, because a level the model does not have must never be written onto the agent.",
+      "additionalProperties": false,
+      "required": ["model"],
+      "properties": {
+        "model": {
+          "type": "string",
+          "description": "Model id without the provider prefix. Must resolve to a profile in this directory, so its limits and retention are known."
+        },
+        "levels": {
+          "type": "array",
+          "items": { "type": "string" },
+          "description": "Effort levels this role's model offers. Omitted means the role emits no variant at all, which is the right reading for a model with no tunable effort."
+        }
+      }
+    },
     "effortRequest": {
       "oneOf": [
         { "type": "string", "description": "Desired level, resolved to the nearest available one." },

package/profiles/space-bunny-free.json

@@ -27,7 +27,7 @@
   },
   "roles": {
     "plan": "max",
-    "build": "high",
+    "build": "max",
     "reviewer": "max",
     "locate": "low",
     "verify": "low"

package/skills/space-finish/SKILL.md

@@ -27,16 +27,6 @@ over an unreviewed or blocked change is the failure this skill exists to stop.
    config or profile, run its verify command. A hand-edit survives a regeneration
    silently, and that is how a zero-retention claim ends up running on a
    may-train model.
-2. **Read the diff once more as a whole.** Reviewers read task by task; you
-   read the change as someone who has never seen it will.
-3. **Check the documentation.** Did this change make a document describe
-   something that no longer exists? Fix the document, do not note it for later.
-4. **Write the summary** a person needs in order to trust the change without
-   reading the whole diff.
-5. **Check the install is still whole.** If this project is driven by a generated
-   config or profile, run its verify command. A hand-edit survives a regeneration
-   silently, and that is how a zero-retention claim ends up running on a
-   may-train model.
 
 ## Summary shape
 
@@ -47,10 +37,10 @@ over an unreviewed or blocked change is the failure this skill exists to stop.
 
 ## The publish boundary
 
-Publishing is a human action. Do not `git push`, do not open a pull request, do
-not publish a package, do not change repository visibility, even if the task
-seems to imply it. The guard will block `git push` in code, but the boundary
-is yours to hold, not only the hook's.
+Publishing needs human approval. Ask before `git push`, opening a pull request,
+publishing a package, or changing repository visibility, even if the task
+seems to imply it. Permissions default to ask so opencode prompts first, but
+the boundary is yours to hold, not only the hook's.
 
 Leave the tree in a state a human can review: on a branch, with the change
 visible in `git diff`.

package/src/config.js

@@ -4,7 +4,7 @@
 // defaults, experimental flags - is fixed here. Everything model-specific is
 // derived from the profile, so switching models changes only the profile file.
 
-import { pruneThreshold, reservedTokens, resolveRoles, resolveDefaultVariant } from "./profile.js"
+import { pruneThreshold, reservedTokens, inputCap, effectiveRetention, resolveRoleModel, resolveRoles, resolveDefaultVariant, roleSplitModels } from "./profile.js"
 
 import { join } from "node:path"
 import { homedir } from "node:os"
@@ -87,8 +87,8 @@ export const BASH_ALLOWLIST = [
 
 /** Hard blocks. The guard plugin enforces the same set in code. */
 export const BASH_DENYLIST = [
-  "git push *",
-  "git push*",
+  // `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",
@@ -143,11 +143,16 @@ export function generateConfig(p, opts = {}) {
   for (const [role, level] of Object.entries(roles)) {
     if (level === undefined) continue
     const existing = { ...(agent[role] ?? {}) }
+    const rm = resolveRoleModel(p, role)
     // The model is pinned, never inherited. Preserving a model already written
     // on the agent is how `build` ended up on a `may-train` model while the rest
     // of the file claimed the profile's zero-retention one: the compiler was
     // asked to re-run over a hand-edited config and kept the hand-edit.
-    existing.model = model
+    //
+    // `roleModels` is the one sanctioned way a role differs, because it is
+    // declared in the profile next to the model it points at and validated
+    // against retention.yml. Still an assignment, never a preserved value.
+    existing.model = rm ? `${p.provider}/${rm.model}` : model
     if (level === null) delete existing.variant
     else existing.variant = level
     if (AGENT_PERMISSIONS[role]) {
@@ -280,22 +285,49 @@ function render(cfg, p, opts) {
   const levels = p.effort?.levels ?? []
   const roles = resolveRoles(p)
 
+  const effective = effectiveRetention(p)
+  // The input cap that actually governs context management, which on a split
+  // profile is the widest role model rather than the base. The header must name
+  // it, or `reserved` and `prune` read as arithmetic against a number that is
+  // not the one they used.
+  const effectiveInput = inputCap(p)
+  const splits = Object.keys(p.roleModels ?? {})
   const head = [
     `${c}Generated by opencode-harness-kit. Edit profiles/${p.id}.json instead`,
     `${c}of this file, then re-run: oc-harness use ${p.id}`,
     `${c}`,
     `${c}profile      ${p.id}`,
     `${c}model        ${p.provider}/${p.model}`,
+    ...(splits.length
+      ? [
+          `${c}split        ${splits.map((r) => `${r}=${p.roleModels?.[r]?.model}`).join("  ")}`,
+          `${c}             (roles not listed above run on the base model above)`,
+        ]
+      : []),
     `${c}context      ${p.limits.context.toLocaleString("en-US")} tokens`,
-    `${c}input cap    ${input.toLocaleString("en-US")} tokens`,
+    `${c}input cap    ${input.toLocaleString("en-US")} tokens${effectiveInput !== input ? `  (base model; ${effectiveInput.toLocaleString("en-US")} governs split roles)` : ""}`,
     `${c}output cap   ${p.limits.output.toLocaleString("en-US")} tokens`,
     `${c}reasoning    ${levels.length ? levels.join(" < ") : "(not tunable)"}`,
-    `${c}retention    ${p.retention}${p.retention === "may-train" ? "  <-- prompts may train a model" : ""}`,
+    // The header must name the retention that actually applies, which with a
+    // split is the least private model in the file, not the base one. Printing
+    // `p.retention` here is the same class of bug as the inherited `build`
+    // model: the file claims a privacy property the agents do not have.
+    `${c}retention    ${effective.retention}${effective.retention === "may-train" ? "  <-- prompts may train a model" : ""}`,
+    ...(effective.retention !== p.retention
+      ? [
+          `${c}             base ${p.provider}/${p.model} is ${p.retention}, but ${effective.worst} makes the whole file ${effective.retention}`,
+        ]
+      : []),
     `${c}`,
     `${c}Derived numbers, do not hand-edit:`,
-    `${c}  compaction.reserved  ${reservedTokens(p).toLocaleString("en-US")}  (${Math.round((p.effort?.reserveShare ?? 0.12) * 100)}% of the input cap, held back for reasoning growth)`,
-    `${c}  prune threshold      ${pruneThreshold(p).toLocaleString("en-US")}  (input cap minus reserve)`,
+    `${c}  compaction.reserved  ${reservedTokens(p).toLocaleString("en-US")}  (${Math.round((p.effort?.reserveShare ?? 0.12) * 100)}% of the governing input cap${effectiveInput !== input ? `, ${effectiveInput.toLocaleString("en-US")} for the widest split role` : ""}, held back for reasoning growth)`,
+    `${c}  prune threshold      ${pruneThreshold(p).toLocaleString("en-US")}  (governing input cap minus reserve)`,
     `${c}  role effort          ${Object.entries(roles).map(([k, v]) => `${k}=${v ?? "unset"}`).join("  ")}`,
+    ...(roleSplitModels(p).length
+      ? [
+          `${c}  role models          ${roleSplitModels(p).map((r) => `${r.role}=${r.model}${r.limits ? ` (out ${r.limits.output.toLocaleString("en-US")})` : ""}`).join("  ")}`,
+        ]
+      : []),
     `${c}  agent steps          ${Object.entries(AGENT_STEPS).filter(([r]) => roles[r]).map(([r, n]) => `${r}=${n}`).join("  ")}`,
   ]