opencode-harness-kit 0.5.8 → 0.6.1

package/bin/oc-harness.mjs

@@ -12,7 +12,7 @@
 // The point of the kit: switching models is a data edit, not a code change.
 // Everything model-specific lives in profiles/<id>.json.
 
-import { chmodSync, copyFileSync, mkdirSync, readFileSync, writeFileSync, existsSync, rmSync, symlinkSync, readdirSync, readlinkSync, realpathSync, lstatSync, appendFileSync } from "node:fs"
+import { chmodSync, copyFileSync, mkdirSync, readFileSync, writeFileSync, existsSync, rmSync, symlinkSync, readdirSync, readlinkSync, realpathSync, lstatSync, appendFileSync, renameSync, unlinkSync } from "node:fs"
 import { homedir } from "node:os"
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path"
 import { execFileSync } from "node:child_process"
@@ -47,6 +47,7 @@ import { generateConfig, globalInstructionsPath, utilityModel, withMemoryPlugin,
 import { ruleNames, BASH_RULES, WRITE_RULES } from "../src/rules.js"
 import { planEffort } from "../src/effort.js"
 import { findTelemetryFiles, readLaneUsage, averageMs } from "../src/lane-usage.js"
+import { researchModels, isWithdrawn, pruneWithdrawnChains } from "../src/research.js"
 import { main as trustMain } from "../src/trust.js"
 
 const CONFIG_DIR =
@@ -1538,7 +1539,7 @@ async function cmdUse(id) {
 
   mkdirSync(dirname(CONFIG_FILE), { recursive: true })
   if (existsSync(CONFIG_FILE)) {
-// The config is the user's file once written. The backup is unconditional:
+    // The config is the user's file once written. The backup is unconditional:
     // `--yes` skips the question, it does not skip the safety net. Gating the
     // backup on `--yes` meant the one path that overwrites without asking was
     // also the one path with nothing to fall back to.
@@ -1559,7 +1560,15 @@ async function cmdUse(id) {
       stamp(`  existing config backed up to ${join(BACKUP_DIR, kept)}`),
     )
   }
-  writeFileSync(CONFIG_FILE, out)
+  // Write atomically to avoid truncating/corrupting the config on crash.
+  const tmp = `${CONFIG_FILE}.${process.pid}.${Date.now()}.tmp`
+  try {
+    writeFileSync(tmp, out)
+    renameSync(tmp, CONFIG_FILE)
+  } catch (err) {
+    try { unlinkSync(tmp) } catch {}
+    throw err
+  }
   console.log(`\n  ${green("✓")} wrote ${CONFIG_FILE}`)
   summary(p)
   console.log(`\n  ${stamp("verify with: opencode debug config")}\n`)
@@ -1702,6 +1711,11 @@ function diffProfile(p, live) {
  * Only machine-derived fields are rewritten. `retention`, `notes`, `roles` and
  * the fallback queue are human judgements and are never touched by a script:
  * losing a privacy verdict to an automated rewrite would be worse than drift.
+ *
+ * The ONE exception is a chain rung the provider has withdrawn. A chain names
+ * the models that could serve a lane, and a withdrawn model is not one of them
+ * any more - it cannot run. Removing it is a derivation from live metadata
+ * and it only ever removes; nothing is ever put INTO a lane.
  */
 /**
  * Refresh every shipped profile against the live catalogue.
@@ -1742,8 +1756,18 @@ async function cmdRefreshAll() {
       gone.push(`${id} (${p.provider}/${p.model})`)
       continue
     }
+    // A model the provider has withdrawn is still IN the catalogue, so the
+    // check above passes it. A profile whose own model was withdrawn has no
+    // chain behind it to fall back to, so there is nothing a refresh can
+    // repair - it has to be retired, and that is a person's call.
+    const prune = pruneWithdrawnChains(p, catalog, p.provider)
+    if (prune.dead) {
+      gone.push(`${id} (${p.provider}/${p.model} was withdrawn from the provider)`)
+      continue
+    }
     const before = diffProfile(p, live)
-    if (!before.length) {
+    const pruned = prune.pruned.length > 0
+    if (!before.length && !pruned) {
       same.push(id)
       continue
     }
@@ -1751,8 +1775,18 @@ async function cmdRefreshAll() {
     // `verified` is the field that says when a profile was last checked
     // against live metadata. Leaving it stale after a refresh makes it a lie.
     p.verified = new Date().toISOString().slice(0, 10)
+    const notes = [...before]
+    if (pruned) {
+      notes.push(`withdrawn rungs removed: ${prune.pruned.join(", ")}`)
+      for (const lane of prune.lanes) {
+        notes.push(`lane ${lane.lane}: ${lane.from.join(", ")} -> ${lane.to.join(", ")}`)
+      }
+      if (prune.utilityMoved) {
+        notes.push(`utility route: ${prune.utilityMoved} -> ${p.utility.model}`)
+      }
+    }
     if (flag("--dryrun")) {
-      changed.push(`${id}: ${before.join(", ")} (dry run, nothing written)`)
+      changed.push(`${id}: ${notes.join("; ")} (dry run, nothing written)`)
       continue
     }
     // A refresh overwrites a file the user may have edited by hand, and for
@@ -1765,7 +1799,7 @@ async function cmdRefreshAll() {
       continue
     }
     writeFileSync(path, `${JSON.stringify(p, null, 2)}\n`)
-    changed.push(`${id}: ${before.join(", ")}`)
+    changed.push(`${id}: ${notes.join("; ")}`)
   }
   console.log(
     `\n${bold("refreshed")}  ${stamp(`${checked} of ${ids.length} profile(s) against the live catalogue`)}\n`,
@@ -2303,8 +2337,30 @@ async function cmdRefresh(id) {
     )
   }
 
+  // A withdrawn model is still in the catalogue, so the check above passes
+  // it. A profile whose own model was withdrawn has no chain behind it, so
+  // there is nothing to fall back to and nothing a refresh can repair.
+  const prune = pruneWithdrawnChains(p, catalog, p.provider)
+  if (prune.dead) {
+    fail(
+      `${p.provider}/${p.model} was withdrawn from the provider.\n` +
+        `  This profile has no chain to fall back to, so it cannot be repaired.\n` +
+        `  Remove it, or point it at a model that is still live.`,
+    )
+  }
+
   const before = diffProfile(p, live)
-  if (before.length === 0) {
+  const notes = [...before]
+  if (prune.pruned.length > 0) {
+    notes.push(`withdrawn rungs removed: ${prune.pruned.join(", ")}`)
+    for (const lane of prune.lanes) {
+      notes.push(`lane ${lane.lane}: ${lane.from.join(", ")} -> ${lane.to.join(", ")}`)
+    }
+    if (prune.utilityMoved) {
+      notes.push(`utility route: ${prune.utilityMoved} -> ${p.utility.model}`)
+    }
+  }
+  if (notes.length === 0) {
     console.log(`\n  ${green("✓")} ${id} already matches live metadata\n`)
     return
   }
@@ -2337,7 +2393,7 @@ async function cmdRefresh(id) {
 
   if (flag("--dryrun")) {
     console.log(`\n  ${stamp("dry run, nothing written")}`)
-    for (const line of before) console.log(`      ${line}`)
+    for (const line of notes) console.log(`      ${line}`)
     return
   }
   // A refresh overwrites a file the user may have edited by hand, and for
@@ -2352,9 +2408,9 @@ async function cmdRefresh(id) {
   }
   writeFileSync(path, `${JSON.stringify(p, null, 2)}\n`)
   console.log(`\n  ${green("✓")} refreshed ${path}`)
-  for (const line of before) console.log(`      ${line}`)
+  for (const line of notes) console.log(`      ${line}`)
   console.log(
-    `\n  ${stamp("kept as-is: retention, roles, notes, fallback (human judgement)")}\n`,
+    `\n  ${stamp("kept as-is: retention, roles, notes (human judgement)")}\n`,
   )
 }
 
@@ -2594,6 +2650,111 @@ async function cmdDoctor() {
 // second doctor in the same process does not inherit the first one's findings.
 const doctorReport = { ok: true, problems: 0, drift: 0, strict: false, findings: [], json: false }
 
+/**
+ * Research the live tier for models the kit could use.
+ *
+ * `doctor` says when a model has gone. This says what has come to replace
+ * it, and what is still a person's decision.
+ *
+ * It writes nothing. The shortlist it prints is a list to argue with, not a
+ * list to accept: `retention` is a judgement about a provider's terms, and
+ * that is the one field a script must not fill in.
+ */
+async function cmdResearch() {
+  const wantJson = flag("--json")
+  let catalog
+  try {
+    catalog = await fetchCatalog()
+  } catch (err) {
+    fail(err instanceof Error ? err.message : String(err), wantJson)
+  }
+
+  // A profile that cannot be read is `doctor`'s finding, not this command's.
+  // Research is about the tier, so a broken profile is left out of the
+  // comparison rather than failing the whole report.
+  const profiles = []
+  for (const id of listProfileIds()) {
+    try {
+      profiles.push(loadProfile(id))
+    } catch {
+      // doctor reports this, with the profile's own name on it.
+    }
+  }
+
+  const report = researchModels({
+    catalog,
+    profiles,
+    retentionOf: (model) => modelRetention(model),
+    defaultProfileId: index().default ?? null,
+  })
+
+  if (wantJson) {
+    console.log(JSON.stringify({ ok: true, ...report }, null, 2))
+    return
+  }
+
+  console.log(
+    `\n${bold("research")}  ${stamp(`tier ${report.tier.provider}, ${report.tier.live} live of ${report.tier.total} free`)}\n`,
+  )
+
+  // The models the kit uses that the provider has pulled. This is the part
+  // that has to be acted on, so it comes first.
+  if (report.shipped.gone.length) {
+    console.log(`  ${red("gone")} ${report.shipped.gone.length} model(s) in use have been withdrawn\n`)
+    for (const g of report.shipped.gone) {
+      console.log(`      ${red("✗")} ${g.id}`)
+      console.log(`        ${g.reason}`)
+      if (g.asBase.length) {
+        console.log(`        ${stamp("base model of")} ${g.asBase.join(", ")}`)
+      }
+      for (const [profile, laneList] of Object.entries(g.inChains ?? {})) {
+        console.log(`        ${stamp("fallback rung in")} ${profile}: ${laneList.join(", ")}`)
+      }
+    }
+    console.log("")
+  } else {
+    console.log(`  ${green("✓")} every model in use is still live\n`)
+  }
+
+  // Per lane: which rungs of its chain are alive. A lane whose whole chain
+  // has gone is a lane with no fallback at all.
+  if (report.lanes.length) {
+    console.log(`  ${bold("lanes")}`)
+    for (const l of report.lanes) {
+      const dead = l.dead.length
+        ? yellow(` ${l.dead.length} dead (${l.dead.join(", ")})`)
+        : green(" 0 dead")
+      console.log(`      ${l.lane.padEnd(12)} ${String(l.live.length).padStart(2)} live${dead}`)
+    }
+    console.log("")
+  }
+
+  // The shortlist. What each candidate can do, which lanes it could serve,
+  // and what is still undecided about it.
+  if (!report.candidates.length) {
+    console.log(`  ${stamp("no live free model outside the ones the kit already uses")}\n`)
+    return
+  }
+  console.log(`  ${bold("candidates")} ${stamp("live, free, and not in use yet")}\n`)
+  for (const c of report.candidates) {
+    const effort = c.effort.length ? c.effort.join(",") : "none published"
+    console.log(
+      `      ${bold(c.id)}  ${stamp(
+        `ctx ${Number(c.context).toLocaleString("en-US")}  out ${Number(c.output).toLocaleString("en-US")}  effort ${effort}`,
+      )}`,
+    )
+    console.log(`        fits: ${c.fits.length ? c.fits.join(", ") : "no lane on its own terms"}`)
+    console.log(
+      `        ${c.retention === "unknown" ? yellow("retention: unknown") : stamp(`retention: ${c.retention}`)}`,
+    )
+    for (const b of c.blockers) console.log(`        ${yellow(b)}`)
+    console.log("")
+  }
+  console.log(
+    `  ${stamp("nothing here is written anywhere. A retention verdict is a person reading a provider's terms.")}\n`,
+  )
+}
+
 async function runDoctor(catalog) {
   const retention = loadRetention().models
   const ids = listProfileIds()
@@ -2641,7 +2802,16 @@ async function runDoctor(catalog) {
     // with no model at all, which no amount of `refresh` on the base profile
     // would reveal.
     for (const [lane, chain] of Object.entries(chainOf(p))) {
-      const alive = chain.filter((rung) => catalog?.[p.provider]?.models?.[rung])
+      // A withdrawn model is still IN the catalog: models.dev keeps the
+      // record and marks it deprecated rather than deleting it. So "is it
+      // still there" is not the same question as "can it still run", and
+      // asking the first one reported a dead model as a healthy fallback.
+      // The message below always said "withdrawn" - only the filter was
+      // wrong, which is why the fleet's dead rung stayed invisible.
+      const alive = chain.filter((rung) => {
+        const record = catalog?.[p.provider]?.models?.[rung]
+        return record && !isWithdrawn(record)
+      })
       if (!alive.length) {
         issues.push(red(`lane ${lane}: every model in its chain has left the catalog`))
       } else if (alive.length < chain.length) {
@@ -3142,6 +3312,9 @@ try {
       if (flag("--watch") || flag("--check-models")) await cmdDoctorWatch()
       else await cmdDoctor()
       break
+    case "research":
+      await cmdResearch()
+      break
     case "baseline":
       await import("./baseline.mjs")
       break
@@ -3174,6 +3347,8 @@ try {
     lanes         report which lanes the fleet actually used
     trust         set up npm trusted publishing for this package
     doctor    re-check profiles against models.dev and the installed config
+    research  find the live free models the kit could use, and the ones in
+              use that have been withdrawn
     upgrade   check for a newer kit, refresh the profiles, rewrite the config
     backups   the configs that were replaced, newest first
     uninstall remove the plugin, prompts, skills and GLOBAL.md again
@@ -3191,8 +3366,8 @@ try {
     --strict       doctor: fail on perishable catalogue drift too
     --watch        doctor: keep watching the catalogue, report what disappeared
     --check-models doctor: one run, non-zero when a shipped model is gone
-    --json        doctor, show, lanes, auto: print the machine-readable form,
-                  and nothing else
+    --json        doctor, show, lanes, auto, research: print the
+                  machine-readable form, and nothing else
     --offline     auto: skip the refresh, for a machine that cannot reach
                   models.dev
     --hook        install: also install the pre-commit hook into this

package/dist/index.js

@@ -1103,7 +1103,10 @@ function normalize(p) {
       keepRecentToolCalls: p.prune?.keepRecentToolCalls ?? 6,
       keepRecentTurns: p.prune?.keepRecentTurns ?? 3,
       keepUserMessages: p.prune?.keepUserMessages ?? true,
-      keepDistinctOutputs: p.prune?.keepDistinctOutputs ?? true
+      keepDistinctOutputs: p.prune?.keepDistinctOutputs ?? true,
+      // null means "the pruner's own budget decides" - the profile's context
+      // budget. A number is a ceiling in characters.
+      keepDistinctBudgetChars: p.prune?.keepDistinctBudgetChars ?? null
     },
     fallback: p.fallback ?? []
   };
@@ -1399,6 +1402,13 @@ function validate(p, path = "<memory>") {
     if (prune.keepDistinctOutputs !== void 0 && typeof prune.keepDistinctOutputs !== "boolean") {
       throw new ProfileError(`${where}: prune.keepDistinctOutputs must be a boolean`);
     }
+    if (prune.keepDistinctBudgetChars !== void 0 && prune.keepDistinctBudgetChars !== null) {
+      if (!Number.isInteger(prune.keepDistinctBudgetChars) || prune.keepDistinctBudgetChars < 0) {
+        throw new ProfileError(
+          `${where}: prune.keepDistinctBudgetChars must be an integer of at least 0`
+        );
+      }
+    }
     if (prune.enabled !== void 0 && typeof prune.enabled !== "boolean") {
       throw new ProfileError(`${where}: prune.enabled must be a boolean`);
     }
@@ -1705,33 +1715,58 @@ var PrunePlugin = async ({ worktree, directory }) => {
     keepTurns: 0,
     keepUsers: true,
     keepDistinct: false,
+    distinctBudget: 0,
     threshold: 0
   };
   let cached = null;
+  let reportedFailure = false;
   const resolve4 = () => {
     if (cached) return cached;
     let profile = null;
     try {
       const id = activeProfileId(project);
       if (id) profile = loadProfile(id);
-    } catch {
+    } catch (err) {
       profile = null;
+      if (!reportedFailure) {
+        reportedFailure = true;
+        console.error(
+          `[opencode-harness-kit] prune disabled: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
     }
     if (!profile?.prune?.enabled) return DISABLED;
+    const threshold = pruneThreshold(profile);
     cached = {
       profile,
       keepCalls: profile.prune.keepRecentToolCalls ?? 6,
       keepTurns: profile.prune.keepRecentTurns ?? 3,
       keepUsers: profile.prune.keepUserMessages ?? true,
       keepDistinct: profile.prune.keepDistinctOutputs ?? true,
-      threshold: pruneThreshold(profile)
+      // The budget the distinct outputs have to fit in.
+      //
+      // It defaults to the profile's own context budget - the number the
+      // pruner is measured against - because a rule with no ceiling is not a
+      // trade-off, it is a leak. Measured on a real 137-message session: the
+      // request was 5.26 MB and the pruner removed 0.04 MB of it (0.8%),
+      // because EVERY distinct output the session had ever produced was kept
+      // (4.74 MB, 92% of the request) "however old it is". The threshold
+      // that session was supposed to live under was 176,000 characters and
+      // the request was 5,140,000 - twenty-nine times over.
+      //
+      // The ceiling keeps the property the rule was added for (the newest
+      // copy of a file the agent read survives, so it does not read it
+      // again) and drops the part that was never wanted (the copy of every
+      // file the session has EVER touched, for ever).
+      distinctBudget: profile.prune.keepDistinctBudgetChars ?? threshold,
+      threshold
     };
     return cached;
   };
   return {
     "experimental.chat.messages.transform": async (_input, output) => {
       try {
-        const { profile, keepCalls, keepTurns, keepUsers, keepDistinct, threshold } = resolve4();
+        const { profile, keepCalls, keepTurns, keepUsers, keepDistinct, distinctBudget, threshold } = resolve4();
         if (!profile) return;
         const messages = output.messages;
         if (!Array.isArray(messages) || messages.length === 0) return;
@@ -1750,17 +1785,30 @@ var PrunePlugin = async ({ worktree, directory }) => {
         }
         if (keepDistinct) {
           const seenSignatures = /* @__PURE__ */ new Set();
+          let kept = 0;
           for (let i = messages.length - 1; i >= 0; i--) {
             const msg = messages[i];
             if (!msg?.parts) continue;
+            let added = 0;
             for (const part of msg.parts) {
               if (part?.type !== "tool") continue;
               if (part.state?.status !== "completed") continue;
               const sig = toolSignature(part);
-              if (!sig || seenSignatures.has(sig)) continue;
+              if (!sig) continue;
+              const seen2 = seenSignatures.has(sig);
               seenSignatures.add(sig);
-              keepToolMessageIds.add(msg.info?.id ?? String(i));
+              if (seen2) continue;
+              if (i >= floor) continue;
+              added += partSize(part);
             }
+            if (added === 0) continue;
+            added = (msg.parts ?? []).reduce(
+              (n, p) => n + partSize(p),
+              0
+            );
+            if (kept + added > distinctBudget) break;
+            kept += added;
+            keepToolMessageIds.add(msg.info?.id ?? String(i));
           }
         }
         const stats = {
@@ -1884,7 +1932,7 @@ function utilityModel(p) {
 }
 
 // src/health.js
-import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync } from "node:fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync3, renameSync as renameSync2, unlinkSync, writeFileSync } from "node:fs";
 import { join as join7 } from "node:path";
 var DEFAULT_WINDOW_MS = 24 * 60 * 60 * 1e3;
 function spentWindowMs() {
@@ -1935,9 +1983,21 @@ function readHealth(dir) {
 }
 function writeHealth(dir, health) {
   try {
-    if (!existsSync5(join7(dir, ".space"))) mkdirSync2(join7(dir, ".space"), { recursive: true });
+    const spaceDir = join7(dir, ".space");
+    if (!existsSync5(spaceDir)) mkdirSync2(spaceDir, { recursive: true });
     const pruned = { ...health ?? {}, unhealthy: liveUnhealthy(health) };
-    writeFileSync(healthPath(dir), JSON.stringify(pruned, null, 2));
+    const file = healthPath(dir);
+    const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+    try {
+      writeFileSync(tmp, JSON.stringify(pruned, null, 2));
+      renameSync2(tmp, file);
+    } catch (err) {
+      try {
+        unlinkSync(tmp);
+      } catch {
+      }
+      throw err;
+    }
   } catch {
   }
 }

package/dist/profile.d.ts

@@ -55,6 +55,7 @@ export type Profile = {
         keepRecentTurns?: number;
         keepUserMessages?: boolean;
         keepDistinctOutputs?: boolean;
+        keepDistinctBudgetChars?: number | null;
     };
     fallback?: string[];
 };
@@ -88,7 +89,7 @@ export type RetentionRecord = {
  * @property {Record<string, RoleModel>} [roleModels]
  * @property {{ enabled?: boolean, keepRecentToolCalls?: number,
  *             keepRecentTurns?: number, keepUserMessages?: boolean,
- *             keepDistinctOutputs?: boolean }} [prune]
+ *             keepDistinctOutputs?: boolean, keepDistinctBudgetChars?: number | null }} [prune]
  * @property {string[]} [fallback]
  * @typedef {{ retention: Retention, note?: string, verified?: string, source?: string }} RetentionRecord
  */

package/docs/KNOWN-LIMITS.md

@@ -373,12 +373,32 @@ RECENT calls was a window on recency, and a long session walks out of it: after
 six more tool calls, the only copy of a file the agent had read was gone, and
 the agent read it again. The long-task A/B measured seventeen re-reads, five
 times the input tokens and the same final context. The rule now keeps the
-newest copy of each distinct output however old it is, and stubs only the
-REPEATS of it. The context grows by the size of the distinct outputs, and the
+newest copy of each distinct output, and stubs only the REPEATS of it. The
 re-reads stop: **-69% input tokens and -60% wall time** on that task, at the
 cost of a bigger context. It is a setting - `prune.keepDistinctOutputs` - and
 turning it off brings the old behaviour back.
 
+**And the distinct outputs have a ceiling.** The rule as it first shipped had
+no upper bound, which made it a leak rather than a trade-off: it kept every
+output the session had ever produced, and a long session grew without limit.
+Measured on a real 137-message session on 2026-10-22: the request was 5.26 MB,
+the pruner removed 0.04 MB of it - 0.8% - and 4.74 MB of it, 92%, was the
+distinct outputs of the whole session. The profile's own budget for that
+request was 176,000 characters, so the request was twenty-nine times over it.
+
+A request that size is not only expensive, it is what makes the server
+slow: opencode persists a full copy of every updated part into its event
+store, so every turn writes megabytes into a database that on that machine had
+reached 4.2 GB, and the TUI - which is a client of that server - started
+dropping keystrokes mid-word.
+
+So the distinct outputs are now kept newest-first and only while they fit in
+a budget: `prune.keepDistinctBudgetChars`, unset meaning the profile's own
+context budget, `0` meaning none. The property the rule was added for still
+holds - the copy of a recent output the agent is working with survives, so it
+does not read the file again - and the part that was never wanted, the copy of
+everything the session has ever touched for ever, is gone.
+
 `savedChars` in `prune.jsonl` is the size of the request before the pass minus
 the size after it, measured on the parts as they are serialised - not on the
 text inside them. It used to measure the text only, and to ignore the state

package/eval/ab.mjs

@@ -750,7 +750,7 @@ console.log("")
 console.log(`  ${"metric (median)".padEnd(16)} ${"kit on".padStart(10)} ${"kit off".padStart(10)}`)
 console.log(`  ${"-".repeat(16)} ${"-".repeat(10)} ${"-".repeat(10)}`)
 for (const [label, a, b] of rows) {
-  console.log(`  ${label.padEnd(16)} ${String(a).padStart(10)} ${String(b).padStart(10)}`)
+  console.log(`  ${String(label).padEnd(16)} ${String(a).padStart(10)} ${String(b).padStart(10)}`)
 }
 
 if (jobs.length > 1) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-harness-kit",
-  "version": "0.5.8",
+  "version": "0.6.1",
   "description": "Harness kit for OpenCode: capability profiles, a fleet of job lanes with one free model each, role-based reasoning effort, context pruning, and measured baselines.",
   "license": "MIT",
   "homepage": "https://github.com/pham-canh/opencode-harness-kit#readme",

package/profiles/beam-free.json

@@ -5,7 +5,7 @@
   "provider": "opencode",
   "model": "beam-free",
   "family": "beam",
-  "verified": "2026-10-19",
+  "verified": "2026-10-22",
   "retention": "retained",
   "notes": "Reflection 501B-A23B, text only, and the freshest knowledge of the free set at 2026-06-30. Measured as the fastest route on the tier: 2.6s average over seven requests. Its provider does not train on prompts but retains them for 30 days, which is why it is `retained` rather than `zero-retention`.",
   "limits": {
@@ -45,7 +45,6 @@
   },
   "fallback": [
     "deepseek-v4.1-flash-free",
-    "glm-5.3-flash-free",
-    "longcat-2.5-preview-free"
+    "glm-5.3-flash-free"
   ]
 }

package/profiles/deepseek-v4.1-flash-free.json

@@ -5,7 +5,7 @@
   "provider": "opencode",
   "model": "deepseek-v4.1-flash-free",
   "family": "deepseek-flash",
-  "verified": "2026-10-19",
+  "verified": "2026-10-22",
   "retention": "zero-retention",
   "notes": "Reasoning plus agentic coding plus structured output on a zero-retention provider. The natural schema lane. Its knowledge cutoff is 2025-05, the oldest of the tier, so it is not the lane for anything that depends on recent facts.",
   "limits": {
@@ -43,7 +43,6 @@
   },
   "fallback": [
     "glm-5.3-flash-free",
-    "longcat-2.5-preview-free",
     "beam-free"
   ]
 }

package/profiles/fleet-all.json

@@ -3,15 +3,15 @@
   "id": "fleet-all",
   "title": "Ten jobs, every free model, one of them may train",
   "provider": "opencode",
-  "model": "minimax-m3.1-flash-free",
-  "family": null,
-  "verified": "2026-10-21",
+  "model": "flint-40b-free",
+  "family": "flint",
+  "verified": "2026-10-22",
   "retention": "may-train",
   "maxRetention": "may-train",
   "notes": "Every lane gets the model built for it: beam plans, Nemotron 3 Ultra reviews, Lightning sweeps, MiMo sees, GLM audits, Super VL reasons with the effort turned off. Five of the ten providers state that collected data may be used to improve the model, or log the session, so the profile as a whole is may-train and the generated config says so in its header. Install it for public or throwaway repositories.",
   "limits": {
-    "context": 1000000,
-    "output": 512000
+    "context": 262144,
+    "output": 65536
   },
   "supports": {
     "reasoning": true,
@@ -49,19 +49,17 @@
   },
   "roleModels": {
     "build": {
-      "model": "minimax-m3.1-flash-free",
+      "model": "flint-40b-free",
       "chain": [
-        "minimax-m3.1-flash-free",
-        "deepseek-v4.1-flash-free",
-        "longcat-2.5-preview-free"
+        "flint-40b-free",
+        "deepseek-v4.1-flash-free"
       ]
     },
     "plan": {
       "model": "beam-free",
       "chain": [
         "beam-free",
-        "deepseek-v4.1-flash-free",
-        "longcat-2.5-preview-free"
+        "deepseek-v4.1-flash-free"
       ]
     },
     "reviewer": {
@@ -77,7 +75,6 @@
       "chain": [
         "nemotron-3.5-lightning-free",
         "big-pickle",
-        "longcat-2.5-preview-free",
         "deepseek-v4.1-flash-free"
       ]
     },
@@ -93,16 +90,14 @@
       "model": "mimo-v2.6-flash-free",
       "chain": [
         "mimo-v2.6-flash-free",
-        "longcat-2.5-preview-free",
-        "minimax-m3.1-flash-free"
+        "deepseek-v4.1-flash-free"
       ]
     },
     "doc": {
       "model": "glm-5.3-flash-free",
       "chain": [
         "glm-5.3-flash-free",
-        "deepseek-v4.1-flash-free",
-        "longcat-2.5-preview-free"
+        "deepseek-v4.1-flash-free"
       ]
     },
     "schema": {
@@ -117,15 +112,13 @@
       "model": "nemotron-3.5-super-vl-free",
       "chain": [
         "nemotron-3.5-super-vl-free",
-        "longcat-2.5-preview-free",
         "beam-free"
       ]
     },
     "longform": {
-      "model": "longcat-2.5-preview-free",
+      "model": "flint-40b-free",
       "chain": [
-        "longcat-2.5-preview-free",
-        "minimax-m3.1-flash-free",
+        "flint-40b-free",
         "beam-free"
       ]
     }
@@ -137,8 +130,7 @@
     "keepUserMessages": true
   },
   "fallback": [
-    "minimax-m3.1-flash-free",
-    "deepseek-v4.1-flash-free",
-    "longcat-2.5-preview-free"
+    "flint-40b-free",
+    "deepseek-v4.1-flash-free"
   ]
 }