opencode-harness-kit 0.5.8 → 0.6.0

package/profiles/glm-5.3-flash-free.json

@@ -5,7 +5,7 @@
   "provider": "opencode",
   "model": "glm-5.3-flash-free",
   "family": "glm-flash",
-  "verified": "2026-10-19",
+  "verified": "2026-10-22",
   "retention": "zero-retention",
   "notes": "Zhipu. The only free model that publishes pdf input, and the only one with structured output and a zero-retention policy at the same time. The pdf does not work: the provider's endpoint rejects a `file` content part, and OpenCode will not read a binary file, so documents are extracted locally first. It measured 4.4-5.8s on the work a lane actually does, and it sits on the thorough lane because it is the careful one rather than the quick one.",
   "limits": {
@@ -43,7 +43,6 @@
   },
   "fallback": [
     "deepseek-v4.1-flash-free",
-    "longcat-2.5-preview-free",
     "beam-free"
   ]
 }

package/profiles/index.json

@@ -68,17 +68,6 @@
       "default": false,
       "note": "Structured output on a zero-retention provider. Careful rather than fast: 4.4-5.8s on the work a lane does."
     },
-    {
-      "id": "longcat-2.5-preview-free",
-      "file": "profiles/longcat-2.5-preview-free.json",
-      "title": "LongCat 2.5 Preview Free",
-      "retention": "zero-retention",
-      "free": true,
-      "topEffort": null,
-      "context": 1000000,
-      "default": false,
-      "note": "1M context with image input and a zero-retention provider. A preview endpoint: it can be withdrawn without a rename."
-    },
     {
       "id": "nemotron-3.5-super-vl-free",
       "file": "profiles/nemotron-3.5-super-vl-free.json",
@@ -156,6 +145,10 @@
     {
       "id": "mimo-v2.5-free",
       "reason": "Withdrawn from the provider. Observed alive for one day. Its replacement on the tier is mimo-v2.6-flash-free."
+    },
+    {
+      "id": "longcat-2.5-preview-free",
+      "reason": "Withdrawn from the provider. A preview endpoint, so it could be pulled without a rename - and it was: models.dev still carries the record and marks it deprecated. It was the longform lane's primary in both fleets, so every lane fell back to its second rung, and the profile named only this model had nothing left to fall back to and was retired."
     }
   ]
 }

package/profiles/mimo-v2.6-flash-free.json

@@ -5,7 +5,7 @@
   "provider": "opencode",
   "model": "mimo-v2.6-flash-free",
   "family": "mimo",
-  "verified": "2026-10-19",
+  "verified": "2026-10-22",
   "retention": "may-train",
   "notes": "Xiaomi. The only free model that publishes audio input, and it read an image correctly in a live call, at 19.2s average - the slowest lane on the tier, and slower than minimax on the same picture. OpenCode 1.19 refuses to read a binary file at all, so the audio path is not reachable through the harness today; the vision path is. No effort levels, so no variant is written.",
   "limits": {
@@ -38,7 +38,6 @@
     "keepUserMessages": true
   },
   "fallback": [
-    "longcat-2.5-preview-free",
     "minimax-m3.1-flash-free"
   ]
 }

package/profiles/minimax-m3.1-flash-free.json

@@ -5,7 +5,7 @@
   "provider": "opencode",
   "model": "minimax-m3.1-flash-free",
   "family": "minimax",
-  "verified": "2026-10-21",
+  "verified": "2026-10-22",
   "retention": "zero-retention",
   "notes": "Flagship coding and agent model on the free tier: 512k output tokens, the widest of any free route, and the fastest measured image reader at 7.7s. Tool calls are stable. It does not support temperature, and models.dev publishes no structured_output flag for it, so JSON output is requested in the prompt rather than negotiated with the API. Measured at 3.1s for a one-word reply.",
   "limits": {
@@ -45,7 +45,6 @@
   },
   "fallback": [
     "deepseek-v4.1-flash-free",
-    "longcat-2.5-preview-free",
     "glm-5.3-flash-free"
   ]
 }

package/profiles/nemotron-3.5-lightning-free.json

@@ -5,7 +5,7 @@
   "provider": "opencode",
   "model": "nemotron-3.5-lightning-free",
   "family": "nemotron-free",
-  "verified": "2026-10-19",
+  "verified": "2026-10-22",
   "retention": "may-train",
   "notes": "Its output cap equals its whole context window, so it is the lane for emitting a file larger than 128k tokens. It publishes no effort level, so it spends nothing on reasoning. It is usually the quickest lane on the tier - 3.7s average over four requests - but one measured call took 114s, so it is not on a latency-sensitive path.",
   "limits": {
@@ -38,7 +38,6 @@
     "keepUserMessages": true
   },
   "fallback": [
-    "big-pickle",
-    "longcat-2.5-preview-free"
+    "big-pickle"
   ]
 }

package/profiles/nemotron-3.5-super-vl-free.json

@@ -5,7 +5,7 @@
   "provider": "opencode",
   "model": "nemotron-3.5-super-vl-free",
   "family": "nemotron-free",
-  "verified": "2026-10-19",
+  "verified": "2026-10-22",
   "retention": "may-train",
   "notes": "NVIDIA 120B-A12B. The only free model that publishes a `none` effort level, which is what makes it the cheap no-reasoning sweep lane. The catalog says it takes images, but a live call with an image attachment hangs and never returns: it is used here for text and for reasoning off, never for pictures. The hang is specific to an attachment - a tool read of the same file answers in 4.2s - so the rule is 'never hand it a file', not 'never use it'.",
   "limits": {
@@ -46,7 +46,6 @@
     "keepUserMessages": true
   },
   "fallback": [
-    "longcat-2.5-preview-free",
     "beam-free"
   ]
 }

package/profiles/schema.json

@@ -267,6 +267,14 @@
           "type": "boolean",
           "default": true,
           "description": "Keep the newest copy of each DISTINCT tool output, however old it is. The recent-calls window is 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 read is gone, and the agent reads it again. The long-task A/B measured seventeen re-reads and five times the input tokens for the same answer."
+        },
+        "keepDistinctBudgetChars": {
+          "type": [
+            "integer",
+            "null"
+          ],
+          "minimum": 0,
+          "description": "The character budget the distinct outputs have to fit in, newest first. The ones past the budget are stubbed like everything else. Null or unset means the profile's own context budget (pruneThreshold), which is what the pruner is measured against: without a ceiling the rule keeps every output the session has ever produced, and on a real 137-message session that was 4.74 MB of a 5.26 MB request against a 176,000 character budget. 0 keeps no distinct output at all."
         }
       }
     },

package/retention.yml

@@ -51,15 +51,6 @@ models:
     verified: 2026-10-19
     source: https://opencode.ai/docs/zen
 
-  opencode/longcat-2.5-preview-free:
-    retention: zero-retention
-    note: >-
-      "Its provider follows a zero-retention policy and does not use your data
-      for model training." Free for a limited time. A preview model: the
-      endpoint can be withdrawn without a rename.
-    verified: 2026-10-19
-    source: https://opencode.ai/docs/zen
-
   # --- Retained: no training, but the provider keeps the data for a stated
   # window. Not the same promise as zero-retention, so it gets its own value. ---
 

package/src/profile.js

@@ -77,7 +77,7 @@ export const ROOT = findRoot(resolve(HERE, ".."))
  * @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
  */
@@ -214,6 +214,9 @@ export function normalize(p) {
       keepRecentTurns: p.prune?.keepRecentTurns ?? 3,
       keepUserMessages: p.prune?.keepUserMessages ?? 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 ?? [],
   }
@@ -738,6 +741,16 @@ export function validate(p, path = "<memory>") {
     ) {
       throw new ProfileError(`${where}: prune.keepDistinctOutputs must be a boolean`)
     }
+    if (prune.keepDistinctBudgetChars !== undefined && 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 !== undefined && typeof prune.enabled !== "boolean") {
       throw new ProfileError(`${where}: prune.enabled must be a boolean`)
     }

package/src/prune.ts

@@ -174,6 +174,8 @@ export const PrunePlugin: Plugin = async ({ worktree, directory }) => {
     // Whether the newest copy of each DISTINCT tool output survives, even
     // when it is older than the recent-calls window.
     keepDistinct: boolean
+    // The character budget the distinct outputs have to fit in.
+    distinctBudget: number
     threshold: number
   }
   const DISABLED: Resolved = {
@@ -182,12 +184,17 @@ export const PrunePlugin: Plugin = async ({ worktree, directory }) => {
     keepTurns: 0,
     keepUsers: true,
     keepDistinct: false,
+    distinctBudget: 0,
     threshold: 0,
   }
   // Only a SUCCESSFUL lookup is cached. A lookup that found nothing is
   // retried on the next request, so a project whose marker appears later
   // still gets pruning.
   let cached: Resolved | null = null
+  // A broken profile is reported once per session, not once per request:
+  // only a SUCCESSFUL lookup is cached, so a failing one is retried on every
+  // request and would otherwise fill the console with the same line.
+  let reportedFailure = false
 
   const resolve = (): Resolved => {
     if (cached) return cached
@@ -195,17 +202,50 @@ export const PrunePlugin: Plugin = async ({ worktree, directory }) => {
     try {
       const id = activeProfileId(project)
       if (id) profile = loadProfile(id)
-    } catch {
+    } catch (err) {
       profile = null
+      if (!reportedFailure) {
+        reportedFailure = true
+        // A profile that cannot be loaded is not a reason to prune silently.
+        //
+        // The catch around the transform below logs when a prune FAILS, and
+        // this one did not: a marker pointing at a renamed or missing
+        // profile turned the pruner off with no line in the log, nothing on
+        // the console, and nothing to show the user why the context kept
+        // growing. A project in that state cannot tell the difference
+        // between "the pruner has nothing to do" and "the pruner is broken".
+        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
   }
@@ -213,7 +253,7 @@ export const PrunePlugin: Plugin = async ({ worktree, directory }) => {
   return {
     "experimental.chat.messages.transform": async (_input: any, output: any) => {
       try {
-        const { profile, keepCalls, keepTurns, keepUsers, keepDistinct, threshold } = resolve()
+        const { profile, keepCalls, keepTurns, keepUsers, keepDistinct, distinctBudget, threshold } = resolve()
         if (!profile) return
         const messages = output.messages
         if (!Array.isArray(messages) || messages.length === 0) return
@@ -257,17 +297,62 @@ export const PrunePlugin: Plugin = async ({ worktree, directory }) => {
         // same input have the same output.
         if (keepDistinct) {
           const seenSignatures = new Set<string>()
+          // What the distinct outputs kept so far cost the request.
+          let kept = 0
           for (let i = messages.length - 1; i >= 0; i--) {
             const msg = messages[i]
             if (!msg?.parts) continue
+            // The size of the NEW distinct outputs in this message. A message
+            // that repeats an output it already has adds nothing, so it is
+            // not charged twice.
+            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 seen = seenSignatures.has(sig)
               seenSignatures.add(sig)
-              keepToolMessageIds.add(msg.info?.id ?? String(i))
+              // A REPEAT is never kept by this rule - the newest copy is.
+              if (seen) continue
+              // Outside the prunable floor the part survives anyway, and it
+              // is the newest copy of its output, so it owns that output: an
+              // older copy of the same thing is stubbed and this one costs
+              // the budget nothing.
+              if (i >= floor) continue
+              added += partSize(part)
             }
+            if (added === 0) continue
+            // The ceiling has to charge what the rule actually KEEPS, and the
+            // rule keeps the WHOLE message - every part in it, verbatim
+            // (see the keepToolMessageIds branch in the main loop).
+            //
+            // Charging only the tool parts left the rest of the message free:
+            // a message with a 300 character tool output and a 4,000
+            // character reasoning part cost the budget 300 and kept 4,300.
+            // With a 5,000 character ceiling, twenty such messages kept
+            // 40,000 characters of reasoning the ceiling had already ruled
+            // out - the rule kept eight times its own budget, and the
+            // reasoning it carried along was exactly what the pruner exists
+            // to stub. There is no floor under which a reasoning part is
+            // left alone, and the ceiling is not one either.
+            added = (msg.parts ?? []).reduce(
+              (n: number, p: any) => n + partSize(p),
+              0,
+            )
+            // The ceiling. The walk is newest-first, so what the agent is
+            // working with survives and what the session touched at the start
+            // is stubbed like everything else.
+            //
+            // Without it the rule is not a trade-off but a leak: measured on a
+            // real 137-message session, the request was 5.26 MB, the pruner
+            // removed 0.04 MB of it, and 4.74 MB of it - 92% - was the
+            // distinct outputs of the whole session, kept "however old it
+            // is". The profile's own budget for that request was 176,000
+            // characters.
+            if (kept + added > distinctBudget) break
+            kept += added
+            keepToolMessageIds.add(msg.info?.id ?? String(i))
           }
         }