opencode-harness-kit 0.4.5 → 0.5.0

package/eval/prepare.mjs

@@ -29,14 +29,23 @@ const flag = (...n) => {
   return i >= 0 ? args[i + 1] : undefined
 }
 
-const repo = flag("--repo")
+let repo = flag("--repo")
 const ref = flag("--ref") ?? "HEAD"
+// A PUBLIC repository, cloned at a pinned commit.
+//
+// The subject of a benchmark that nobody can fetch is a result nobody can
+// check. The pilot that used a private repository had that problem, and the
+// fix is one command: give the suite a URL and a SHA, and the harness does
+// the clone.
+const cloneUrl = flag("--clone")
 const from = flag("--from")
 const wantJson = args.includes("--json")
 const name = flag("--name")
 
-if (!repo && !from) {
-  console.error("usage: node eval/prepare.mjs (--repo <path> [--ref <sha>] | --from <path>) [--name <n>] [--json]")
+if (!repo && !from && !cloneUrl) {
+  console.error(
+    "usage: node eval/prepare.mjs (--repo <path> [--ref <sha>] | --clone <url> [--ref <sha>] | --from <path>) [--name <n>] [--json]",
+  )
   process.exit(1)
 }
 if (repo && from) {
@@ -110,7 +119,7 @@ function safeLabel(raw) {
   return raw
 }
 
-const requested = name ?? (from ? basename(from) : `${basename(repo ?? "repo")}-${ref}`)
+const requested = name ?? (from ? basename(from) : `${basename(repo ?? cloneUrl ?? "repo")}-${ref}`)
 const label = safeLabel(requested)
 if (!label) {
   console.error(`--name must be a single directory name, not a path: ${requested}`)
@@ -130,6 +139,27 @@ mkdirSync(out, { recursive: true })
 
 let source
 let pinned
+if (cloneUrl) {
+  // A shallow fetch of the one commit. A full clone of a public repository
+  // is a lot of megabytes to throw away, and the benchmark needs one tree.
+  const cloneDir = join(scratch, `.clone-${label}`)
+  rmSync(cloneDir, { recursive: true, force: true })
+  mkdirSync(cloneDir, { recursive: true })
+  const git = (args) =>
+    execFileSync("git", ["-C", cloneDir, ...args], { encoding: "utf8" })
+  try {
+    git(["init", "--quiet"])
+    git(["remote", "add", "origin", cloneUrl])
+    git(["fetch", "--depth", "1", "--quiet", "origin", ref])
+    git(["checkout", "--quiet", "FETCH_HEAD"])
+  } catch (err) {
+    console.error(
+      `cannot fetch ${ref} from ${cloneUrl}: ${err instanceof Error ? err.message : String(err)}`,
+    )
+    process.exit(1)
+  }
+  repo = cloneDir
+}
 if (from) {
   if (!existsSync(from)) {
     console.error(`--from path not found: ${from}`)

package/eval/tasks-long.json

@@ -0,0 +1,55 @@
+{
+  "$comment": [
+    "The long task: one change, many files, and a question about the code.",
+    "",
+    "The A/B in tasks-self.json is made of short tasks - a prompt of two or",
+    "three hundred characters, answered in one or two reads. On those the kit",
+    "is a cost, and the measurement says so: over five times the input tokens",
+    "and a tie on correctness.",
+    "",
+    "That is the wrong task for the kit's central claim. The claim is that",
+    "the pruner pays for itself on a LONG session, and nothing in the short",
+    "suite can show that: a short session never grows the history far enough",
+    "for pruning to matter.",
+    "",
+    "So this suite has one task, and it is long. It touches twelve files, so",
+    "the agent has to read twelve of them, and it has to answer a question",
+    "about the code that CONSUMES the thing it changed - so it has to find",
+    "that code and read it too. The conversation is long because the work is",
+    "long, which is the only way the measurement can be honest.",
+    "",
+    "It is graded on BOTH halves: the change is compared against the pristine",
+    "subject file by file, and the answer is graded by citation. An agent",
+    "that made the change but did not find the code has not finished.",
+    "",
+    "The change is one the kit's own history actually contains: a last-resort",
+    "fallback added to every profile."
+  ],
+  "snapshot": "this repository, at the commit the suite is committed with",
+  "tasks": [
+    {
+      "id": "long-fallback-sweep",
+      "$comment": "Twelve files to read, eleven to change, one trap, and a question about the code that reads the thing that changed.",
+      "task": "In this repository, every profile in `profiles/` has a `fallback` list: the models to try, in order, when the profile's own model is withdrawn from the tier. `big-pickle` is the cheapest text-only model on the tier, so it is the right last resort. Append `big-pickle` to the end of the `fallback` list of every profile — EXCEPT `profiles/big-pickle.json` itself, because a model cannot fall back to itself. Do not change any other field in those files, and do not change any other file. When you are done, report the file and the line where the code reads that `fallback` list and decides which model to use next, and quote the line.",
+      "want": "const queue = [id, ...(profile.fallback ?? [])]",
+      "mutateMany": {
+        "field": "fallback",
+        "append": "big-pickle",
+        "files": [
+          "profiles/beam-free.json",
+          "profiles/deepseek-v4.1-flash-free.json",
+          "profiles/fleet-all.json",
+          "profiles/fleet-safe.json",
+          "profiles/glm-5.3-flash-free.json",
+          "profiles/longcat-2.5-preview-free.json",
+          "profiles/mimo-v2.6-flash-free.json",
+          "profiles/minimax-m3.1-flash-free.json",
+          "profiles/nemotron-3-ultra-free.json",
+          "profiles/nemotron-3.5-lightning-free.json",
+          "profiles/nemotron-3.5-super-vl-free.json"
+        ],
+        "except": ["profiles/big-pickle.json"]
+      }
+    }
+  ]
+}

package/eval/tasks-process.json

@@ -0,0 +1,40 @@
+{
+  "$comment": [
+    "The process, measured: a reviewer that does not edit.",
+    "",
+    "The kit claims three process things the correctness A/B cannot see: a",
+    "reviewer that reviews and does not edit, a verify that runs the checks and",
+    "does not fix them, and a publish decision that belongs to a human.",
+    "",
+    "The first is measurable, and this measures it. The task INVITES the agent",
+    "to fix what it finds - the file is wrong, fix it - and the grading has two",
+    "halves: the finding has to be CITED, so the work was done, and the file has",
+    "to be UNTOUCHED, so the agent reported instead of fixed.",
+    "",
+    "The arm with the kit runs the REVIEWER lane, whose prompt says: 'You",
+    "review. You never fix, because a reviewer who edits stops being a",
+    "reviewer.' The arm without the kit has no lanes and gets the default",
+    "agent, asked the same question. So the difference being measured is the",
+    "kit's, and the lane is part of the kit.",
+    "",
+    "The finding is real and was found by reading the code: the page describes",
+    "the pruner as it was before the distinct-output rule.",
+    "The task says 'tell me', not 'fix it'. A task that says 'fix it' overrides the lane: the reviewer prompt says 'You never fix', and the agent follows the task anyway. That was measured, and it is a limit of the lane rather than a property of it - see docs/KNOWN-LIMITS.md."
+  ],
+  "snapshot": "this repository, at the commit the suite is committed with",
+  "tasks": [
+    {
+      "id": "review-no-edit",
+      "$comment": "A review, invited to fix. The kit's reviewer reports instead.",
+      "task": "In this repository, the section about pruning in `docs/KNOWN-LIMITS.md` no longer matches the pruner in `src/prune.ts`. The page says the stub means the agent has to re-run a command to see the output again; the pruner no longer works that way. Review it and tell me what needs to change, with the file and the line, and quote the line.",
+      "want": "keepDistinct: profile.prune.keepDistinctOutputs ?? true,",
+      "mutate": {
+        "file": "src/prune.ts",
+        "mustNotChange": [
+          "src/prune.ts",
+          "docs/KNOWN-LIMITS.md"
+        ]
+      }
+    }
+  ]
+}

package/eval/tasks-ts.json

@@ -1,50 +1,56 @@
 {
   "$comment": [
-    "TypeScript subject. The kit is TypeScript and the Python suite in tasks.json",
-    "never tested that, which is the gap this file exists to close.",
-    "The subject is a PRIVATE repository, so this suite is a pilot that",
-    "nobody can repeat. The repeatable one is tasks-self.json.",
+    "TypeScript subject, and this one is PUBLIC.",
     "",
-    "Subject is vendor/gibwork-sentinel from gibwork-agent-harness: 692 lines of",
-    "TypeScript across 7 modules, shipped alongside compiled JavaScript in dist/.",
-    "Every answer below occurs in src/ and again in dist/. Each task says so",
-    "explicitly, because picking the build output instead of the source is the",
-    "trap and the reason this subject is worth having.",
+    "The earlier TypeScript pilot ran against a private repository, which",
+    "means nobody else could repeat it - the same problem the self-suite",
+    "was written to solve. This subject is public, pinned by commit, and",
+    "cloned by the harness itself:",
     "",
-    "All three wants were checked to occur in exactly one file under src/.",
-    "That check is what stops an ambiguous task - two of the earlier ones were",
-    "wrong for exactly that reason."
+    "    node eval/prepare.mjs --clone https://github.com/typesense/typesense-js \\",
+    "      --ref 337fb8599d2e916090d943dd3b9895b71c383711 --name ts",
+    "",
+    "It is the official TypeScript SDK for Typesense, Apache-2.0, about",
+    "five megabytes. The source is under src/Typesense/ and the COMPILED",
+    "JavaScript is committed next to it, in lib/Typesense/ and again in the",
+    "unminified bundle dist/typesense.js.",
+    "",
+    "That is the trap, and it is the reason this subject is worth having:",
+    "every answer below occurs THREE times - in the TypeScript source, in the",
+    "compiled module, and in the bundle. An agent that greps and stops at the",
+    "build output is wrong, and the bundle even keeps the original module",
+    "banners, so a search for a source path lands straight in the bundle.",
+    "",
+    "Each want was checked to occur in EXACTLY ONE file under src/, which is",
+    "the check that stops an ambiguous task. Re-check with:",
+    "",
+    "    git archive --remote=<url> <sha> src | tar -x && grep -rn <want> src/"
   ],
-  "snapshot": "gibwork-agent-harness/vendor/gibwork-sentinel (not a git repo, copied as-is)",
+  "snapshot": "https://github.com/typesense/typesense-js at 337fb8599d2e916090d943dd3b9895b71c383711 (v3.2.0), cloned by eval/prepare.mjs --clone",
   "tasks": [
     {
-      "id": "ts-rpc-default",
-      "task": "This package is shipped as both TypeScript sources and compiled JavaScript. In the TypeScript source only, not the build output, which module declares the default Solana RPC endpoint, and what is that URL? Report the file and line. Do not modify any files.",
-      "want": "https://api.mainnet-beta.solana.com"
+      "id": "ts-default-port",
+      "$comment": "One constant, in a file that also exists three times compiled.",
+      "task": "This package is shipped as TypeScript sources AND as compiled JavaScript. In the TypeScript source only, not the build output, the client is given a default port for a node that speaks HTTPS. Which port, in which module, and on what line? Report the file and the line and quote the line. Do not modify any files.",
+      "want": "node[\"port\"] = 443;"
     },
     {
-      "id": "ts-rest-client",
-      "task": "This package is shipped as both TypeScript sources and compiled JavaScript. In the TypeScript source only, not the build output, which module exports the class that talks to the Gibwork REST API? Report the file and line. Do not modify any files.",
-      "want": "export class GibworkClient"
+      "id": "ts-default-export",
+      "$comment": "The package's default export - one line, and it is in the bundle too.",
+      "task": "This package is shipped as TypeScript sources AND as compiled JavaScript. In the TypeScript source only, not the build output, the package's default export names three things. Which three, in which file, and on what line? Report the file and the line and quote the line. Do not modify any files.",
+      "want": "export default { Client, SearchClient, Errors };"
     },
     {
-      "id": "ts-pr-template",
-      "task": "This package is shipped as both TypeScript sources and compiled JavaScript. In the TypeScript source only, not the build output, one module writes a pull request template file into the generated workspace. Which module writes it, and what is the filename? Report the file and line. Do not modify any files.",
-      "want": "PULL_REQUEST_TEMPLATE.md"
+      "id": "ts-export-stream",
+      "$comment": "A method, in a source file that is compiled into the same directory.",
+      "task": "This package is shipped as TypeScript sources AND as compiled JavaScript. In the TypeScript source only, not the build output, one class has an async method that streams the export of a collection. Which class, which method, and on what line? Report the file and the line and quote the line. Do not modify any files.",
+      "want": "async exportStream("
     },
     {
-      "id": "ts-edit-rpc",
-      "$comment": "The edit task, which the TypeScript suite was missing. mustNotContain is as important as mustContain: the same string is in dist/solana.js too, so an agent that edits the build output instead of the source gets mustNotContain for free and is caught.",
-      "task": "In the TypeScript source of this package, the Solana verifier defaults to the mainnet RPC endpoint. Change that default to the devnet endpoint at https://api.devnet.solana.com. Make no other changes and do not reformat anything.",
-      "mutate": {
-        "file": "src/solana.ts",
-        "mustContain": [
-          "api.devnet.solana.com"
-        ],
-        "mustNotContain": [
-          "api.mainnet-beta.solana.com"
-        ]
-      }
+      "id": "ts-union-doc",
+      "$comment": "A documentation URL, in a comment - and the compiled copy keeps the comment too.",
+      "task": "This package is shipped as TypeScript sources AND as compiled JavaScript. In the TypeScript source only, not the build output, there is a comment that tells the reader which page documents federated multi-search with a union. Which URL, in which file, and on what line? Report the file and the line and quote the line. Do not modify any files.",
+      "want": "https://typesense.org/docs/29.0/api/federated-multi-search.html#union-search"
     }
   ]
 }

package/eval/verify.mjs

@@ -263,9 +263,125 @@ export function gradeAnswer(target, text, want, { window = 1, exclude = [] } = {
  * says "in every one of the six profiles" is not done by editing the first two,
  * and a plain substring check would pass it happily.
  */
-export function gradeMutation(runDir, spec) {
+/**
+ * Grade a change that spans many files.
+ *
+ * A long task is a change to many files at once, and a grader that only
+ * knows how to look at one of them cannot say whether the other eleven were
+ * touched. So the check is a COMPARISON against the pristine subject: each
+ * file in the run copy must be the original with exactly one thing changed -
+ * the named field, with the named entry appended - and everything else in it
+ * byte for byte the same.
+ *
+ * Without the comparison, "the last entry is right" passes an agent that
+ * also reformatted the file, dropped a lane, or deleted a profile. With it,
+ * the check says what the change was.
+ *
+ * @param {string} runDir the run's copy of the subject
+ * @param {{ field: string, append: string, files: string[], except?: string[] }} spec
+ * @param {{ pristine?: string }} [opts] the pristine subject, for the comparison
+ * @returns {{ ok: boolean, reason?: string, changed?: string[] }}
+ */
+export function gradeMutationMany(runDir, spec, { pristine } = {}) {
+  const changed = []
+  // The files that must NOT change. A model cannot fall back to itself, so
+  // the profile for the appended model is left alone - and an agent that
+  // appends it anyway has made a change nobody asked for.
+  for (const file of spec.except ?? []) {
+    const abs = resolveInTarget(runDir, file)
+    if (!abs) return { ok: false, reason: `${file} missing from the run copy` }
+    if (!pristine) continue
+    const origAbs = resolveInTarget(pristine, file)
+    if (!origAbs) return { ok: false, reason: `${file} missing from the pristine subject` }
+    let now
+    let orig
+    try {
+      now = readFileSync(abs, "utf8")
+      orig = readFileSync(origAbs, "utf8")
+    } catch (e) {
+      return { ok: false, reason: `${file} unreadable: ${errorMessage(e)}` }
+    }
+    if (now !== orig) {
+      return { ok: false, reason: `${file} was changed, and it was not one of the files to change` }
+    }
+  }
+  for (const file of spec.files ?? []) {
+    const abs = resolveInTarget(runDir, file)
+    if (!abs) return { ok: false, reason: `${file} missing from the run copy` }
+    let data
+    try {
+      data = JSON.parse(readFileSync(abs, "utf8"))
+    } catch (e) {
+      return { ok: false, reason: `${file} is not valid JSON: ${errorMessage(e)}` }
+    }
+    const arr = data?.[spec.field]
+    if (!Array.isArray(arr)) {
+      return { ok: false, reason: `${file} has no ${spec.field} array` }
+    }
+    if (arr[arr.length - 1] !== spec.append) {
+      return {
+        ok: false,
+        reason: `${file}: the last ${spec.field} entry is ${JSON.stringify(arr[arr.length - 1])}, not ${JSON.stringify(spec.append)}`,
+      }
+    }
+    // The comparison with the original. Everything but the one field has to
+    // be identical, and the field itself has to be the original plus the one
+    // entry - no reordering, no removal, nothing else added.
+    if (!pristine) continue
+    const origAbs = resolveInTarget(pristine, file)
+    if (!origAbs) return { ok: false, reason: `${file} missing from the pristine subject` }
+    let orig
+    try {
+      orig = JSON.parse(readFileSync(origAbs, "utf8"))
+    } catch (e) {
+      return { ok: false, reason: `${file} unreadable in the subject: ${errorMessage(e)}` }
+    }
+    const origArr = orig?.[spec.field]
+    if (!Array.isArray(origArr)) {
+      return { ok: false, reason: `${file} has no ${spec.field} array in the subject` }
+    }
+    const expected = origArr[origArr.length - 1] === spec.append ? origArr : [...origArr, spec.append]
+    if (JSON.stringify(arr) !== JSON.stringify(expected)) {
+      return {
+        ok: false,
+        reason: `${file}: the ${spec.field} list is not the original with ${JSON.stringify(spec.append)} appended`,
+      }
+    }
+    for (const key of Object.keys(orig)) {
+      if (key === spec.field) continue
+      if (JSON.stringify(data?.[key]) !== JSON.stringify(orig[key])) {
+        return { ok: false, reason: `${file}: ${key} changed, and only ${spec.field} was asked for` }
+      }
+    }
+    if (JSON.stringify(arr) !== JSON.stringify(origArr)) changed.push(file)
+  }
+  return { ok: true, changed }
+}
+
+export function gradeMutation(runDir, spec, { pristine } = /** @type {{ pristine?: string }} */ ({})) {
   const abs = resolveInTarget(runDir, spec.file)
   if (!abs) return { ok: false, reason: `${spec.file} missing from the run copy` }
+  // The files that had to stay as they were. A review that fixes what it
+  // reviews is not a review, and a verify that repairs what it checks is not
+  // a check - so the assertion is that the file is untouched, byte for byte.
+  for (const file of spec.mustNotChange ?? []) {
+    const now = resolveInTarget(runDir, file)
+    if (!now) return { ok: false, reason: `${file} missing from the run copy` }
+    if (!pristine) continue
+    const orig = resolveInTarget(pristine, file)
+    if (!orig) return { ok: false, reason: `${file} missing from the pristine subject` }
+    let a
+    let b
+    try {
+      a = readFileSync(now, "utf8")
+      b = readFileSync(orig, "utf8")
+    } catch (e) {
+      return { ok: false, reason: `${file} unreadable: ${errorMessage(e)}` }
+    }
+    if (a !== b) {
+      return { ok: false, reason: `${file} was changed, and it was not one of the files to change` }
+    }
+  }
   let body
   try {
     body = readFileSync(abs, "utf8")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-harness-kit",
-  "version": "0.4.5",
+  "version": "0.5.0",
   "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/space-harness#readme",

package/profiles/schema.json

@@ -262,6 +262,11 @@
           "type": "boolean",
           "default": true,
           "description": "Never stub anything inside a user message. Their instructions are the point of the session. This covers a tool result a user attached as well as their text: user text is kept either way, because prose is kept everywhere."
+        },
+        "keepDistinctOutputs": {
+          "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."
         }
       }
     },

package/src/profile.js

@@ -76,7 +76,8 @@ export const ROOT = findRoot(resolve(HERE, ".."))
  * @property {Record<string, EffortRequest>} [roles]
  * @property {Record<string, RoleModel>} [roleModels]
  * @property {{ enabled?: boolean, keepRecentToolCalls?: number,
- *             keepRecentTurns?: number, keepUserMessages?: boolean }} [prune]
+ *             keepRecentTurns?: number, keepUserMessages?: boolean,
+ *             keepDistinctOutputs?: boolean }} [prune]
  * @property {string[]} [fallback]
  * @typedef {{ retention: Retention, note?: string, verified?: string, source?: string }} RetentionRecord
  */
@@ -202,6 +203,7 @@ export function normalize(p) {
       keepRecentToolCalls: p.prune?.keepRecentToolCalls ?? 6,
       keepRecentTurns: p.prune?.keepRecentTurns ?? 3,
       keepUserMessages: p.prune?.keepUserMessages ?? true,
+      keepDistinctOutputs: p.prune?.keepDistinctOutputs ?? true,
     },
     fallback: p.fallback ?? [],
   }
@@ -665,6 +667,12 @@ export function validate(p, path = "<memory>") {
     if (prune.keepUserMessages !== undefined && typeof prune.keepUserMessages !== "boolean") {
       throw new ProfileError(`${where}: prune.keepUserMessages must be a boolean`)
     }
+    if (
+      prune.keepDistinctOutputs !== undefined &&
+      typeof prune.keepDistinctOutputs !== "boolean"
+    ) {
+      throw new ProfileError(`${where}: prune.keepDistinctOutputs must be a boolean`)
+    }
     if (prune.enabled !== undefined && typeof prune.enabled !== "boolean") {
       throw new ProfileError(`${where}: prune.enabled must be a boolean`)
     }

package/src/prune.ts

@@ -67,6 +67,27 @@ interface StubStats {
 }
 
 /** Rough size of a part, used only for the stats line. */
+/**
+ * The identity of a tool call's output: the tool and what it was asked for.
+ *
+ * Two calls with the same tool and the same input have the same output, so
+ * this is what says "the agent already has this".
+ *
+ * @param {any} part
+ * @returns {string | null}
+ */
+function toolSignature(part: any): string | null {
+  const tool = part?.state?.tool ?? part?.tool
+  if (!tool) return null
+  let input: string
+  try {
+    input = JSON.stringify(part?.state?.input ?? {})
+  } catch {
+    return null
+  }
+  return `${tool} ${input}`
+}
+
 function sizeOf(part: any): number {
   // CHARACTERS, not bytes. A UTF-8 character is more than one byte, and a
   // report that says "bytes" and counts characters is off by a factor on
@@ -128,6 +149,9 @@ export const PrunePlugin: Plugin = async ({ worktree, directory }) => {
     keepCalls: number
     keepTurns: number
     keepUsers: boolean
+    // Whether the newest copy of each DISTINCT tool output survives, even
+    // when it is older than the recent-calls window.
+    keepDistinct: boolean
     threshold: number
   }
   const DISABLED: Resolved = {
@@ -135,6 +159,7 @@ export const PrunePlugin: Plugin = async ({ worktree, directory }) => {
     keepCalls: 0,
     keepTurns: 0,
     keepUsers: true,
+    keepDistinct: false,
     threshold: 0,
   }
   // Only a SUCCESSFUL lookup is cached. A lookup that found nothing is
@@ -157,6 +182,7 @@ export const PrunePlugin: Plugin = async ({ worktree, directory }) => {
       keepCalls: profile.prune.keepRecentToolCalls ?? 6,
       keepTurns: profile.prune.keepRecentTurns ?? 3,
       keepUsers: profile.prune.keepUserMessages ?? true,
+      keepDistinct: profile.prune.keepDistinctOutputs ?? true,
       threshold: pruneThreshold(profile),
     }
     return cached
@@ -165,7 +191,7 @@ export const PrunePlugin: Plugin = async ({ worktree, directory }) => {
   return {
     "experimental.chat.messages.transform": async (_input: any, output: any) => {
       try {
-        const { profile, keepCalls, keepTurns, keepUsers, threshold } = resolve()
+        const { profile, keepCalls, keepTurns, keepUsers, keepDistinct, threshold } = resolve()
         if (!profile) return
         const messages = output.messages
         if (!Array.isArray(messages) || messages.length === 0) return
@@ -191,6 +217,38 @@ export const PrunePlugin: Plugin = async ({ worktree, directory }) => {
           }
         }
 
+        // The newest copy of each DISTINCT tool output survives, however old
+        // it is.
+        //
+        // The recent-calls window is a window on RECENCY, and a long session
+        // walks straight out of it: after six more tool calls, the one and
+        // only copy of a file the agent read is gone, and the agent reads it
+        // again. The long-task A/B measured it - seventeen re-reads, five
+        // times the input tokens, and the same final context at the end.
+        //
+        // What the agent needs is the file, not the freshness of the copy.
+        // So a distinct output is kept once, at its newest occurrence, and
+        // only the REPEATS of it are stubbed. The context grows by the size
+        // of the distinct outputs; the re-reads stop.
+        //
+        // The signature is the tool and its input, because two calls with the
+        // same input have the same output.
+        if (keepDistinct) {
+          const seenSignatures = new Set<string>()
+          for (let i = messages.length - 1; i >= 0; i--) {
+            const msg = messages[i]
+            if (!msg?.parts) continue
+            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
+              seenSignatures.add(sig)
+              keepToolMessageIds.add(msg.info?.id ?? String(i))
+            }
+          }
+        }
+
         const stats: StubStats = {
           stubbed: 0,
           kept: 0,