opencode-harness-kit 0.4.2 → 0.4.4

package/src/profile.js

@@ -42,7 +42,7 @@ const HERE = dirname(fileURLToPath(import.meta.url))
 /** @param {string} start @returns {string} */
 function findRoot(start) {
   let dir = start
-  for (let i = 0; i < 6; i++) {
+  for (let i = 0; i < 12; i++) {
     if (existsSync(join(dir, "profiles"))) return dir
     const parent = dirname(dir)
     if (parent === dir) break
@@ -64,6 +64,7 @@ export const ROOT = findRoot(resolve(HERE, ".."))
  * @property {string} provider
  * @property {string} model
  * @property {string | null} [family]
+ * @property {{ model: string, why?: string }} [utility] the route for opencode's short auxiliary calls
  * @property {string} [verified]
  * @property {Retention} retention
  * @property {Retention} [maxRetention]
@@ -105,14 +106,41 @@ export const WORKFLOW_LANES = ["build", "plan", "reviewer", "locate", "verify"]
 
 // Retention, ordered safest-first. A fleet is labelled with the worst level
 // among the models it actually resolves to.
-const RETENTION_SEVERITY = ["zero-retention", "retained", "unknown", "may-train"]
+//
+// `unknown` is the worst of the known levels on purpose. `retentionAllowed`
+// refuses it outright - a lane that would run on a model nobody has stated
+// the terms of is worse than a lane that runs on a worse model with known
+// terms - and a severity table that ranked it as milder than `may-train`
+// contradicted that: a profile with an unknown-retention model in it was
+// reported as safer than one with a training provider.
+const RETENTION_SEVERITY = ["zero-retention", "retained", "may-train", "unknown"]
+
+/**
+ * How bad a retention level is, as a number. Bigger is worse.
+ *
+ * `unknown` is the worst of them. `retentionAllowed` refuses it outright - a
+ * lane that would run on a model nobody has stated the terms of is worse
+ * than a lane that runs on a worse model with known terms - so a severity
+ * table that ranked it as milder than `may-train` contradicted the rule it
+ * sits next to.
+ *
+ * @param {string} level
+ * @returns {number} the rank, or -1 for a level that is not one of them
+ */
+export function retentionSeverity(level) {
+  return RETENTION_SEVERITY.indexOf(/** @type {Retention} */ (level))
+}
 
 /**
  * Profiles live in profiles/ (verified). schema.json and index.json are not
  * profiles.
  */
 export function profileDirs() {
-  return [join(ROOT, "profiles")]
+  // The profiles can live somewhere else. A test that refreshes a profile
+  // would otherwise rewrite the kit's own data - which is what happened the
+  // first time this was tried - and a user who keeps profiles in their own
+  // tree cannot use the kit at all.
+  return [process.env.OPENCODE_HARNESS_PROFILES ?? join(ROOT, "profiles")]
 }
 
 /** @param {string} id @returns {string | null} */
@@ -229,15 +257,31 @@ export function laneNames() {
  * blocks and plain scalars costs about forty lines, which is less than a
  * dependency for a file this shape.
  *
- * @returns {Record<string, RetentionRecord>}
+ * Cached, like the lane table: `retentionFor` is called for every candidate
+ * of every lane, and every candidate of every lane re-read and re-parsed
+ * the whole file.
+ *
+ * The `defaults:` block is read, because it LOOKS like configuration and
+ * was not: the fallback for a model with no entry was hardcoded in the
+ * reader, so changing `defaults.unknown` in the file did nothing.
+ *
+ * @returns {{ models: Record<string, RetentionRecord>, defaults: Record<string, string> }}
  */
+/** @type {{ models: Record<string, RetentionRecord>, defaults: Record<string, string> } | null} */
+let retentionCache = null
 export function loadRetention() {
+  if (retentionCache) return retentionCache
   const file = join(ROOT, "retention.yml")
-  if (!existsSync(file)) return {}
-  const out = /** @type {Record<string, any>} */ ({})
+  if (!existsSync(file)) {
+    retentionCache = { models: {}, defaults: {} }
+    return retentionCache
+  }
+  const models = /** @type {Record<string, any>} */ ({})
+  const defaults = /** @type {Record<string, string>} */ ({})
   const lines = readFileSync(file, "utf8").split("\n")
 
   let current = null
+  let inDefaults = false
   let i = 0
 
   while (i < lines.length) {
@@ -249,12 +293,31 @@ export function loadRetention() {
       i++
       continue
     }
-    // A model key sits at two-space indent under `models:`. Keys are written
-    // provider-qualified already, so do not re-prefix them.
+    // `defaults:` is a top-level block, and its values are plain scalars.
+    if (indent === 0 && line === "defaults:") {
+      inDefaults = true
+      current = null
+      i++
+      continue
+    }
+    if (indent === 0 && line === "models:") {
+      inDefaults = false
+      current = null
+      i++
+      continue
+    }
+    if (inDefaults) {
+      const pair = line.match(/^([a-z-]+)\s*:\s*(\S+)\s*$/)
+      if (pair) defaults[pair[1]] = pair[2]
+      i++
+      continue
+    }
+    // A model key sits at two-space indent under `models:`. A key with no
+    // provider prefix gets one, so a lookup by bare model id finds it.
     if (indent === 2 && line.endsWith(":")) {
       const key = line.slice(0, -1).trim()
       current = key.includes("/") ? key : `opencode/${key}`
-      out[current] = { retention: "unknown" }
+      models[current] = { retention: "unknown" }
       i++
       continue
     }
@@ -281,17 +344,18 @@ export function loadRetention() {
           if (l.length - l.trimStart().length <= indent) break
           parts.push(l.trim())
         }
-        out[current][name] = parts.join(" ").replace(/\s+/g, " ").trim()
+        models[current][name] = parts.join(" ").replace(/\s+/g, " ").trim()
         i = j
         continue
       }
-      out[current][name] = rest.replace(/^["']|["']$/g, "")
+      models[current][name] = rest.replace(/^["']|["']$/g, "")
       i++
       continue
     }
     i++
   }
-  return out
+  retentionCache = { models, defaults }
+  return retentionCache
 }
 
 /**
@@ -301,17 +365,27 @@ export function loadRetention() {
  * @returns {RetentionRecord | undefined}
  */
 export function retentionFor(id) {
-  const table = loadRetention()
+  const table = loadRetention().models
   return table[id] ?? table[id.includes("/") ? id : `opencode/${id}`]
 }
 
 /**
- * The retention of a model id, qualified or not.
+ * The retention of a model id, out of a retention table.
+ *
+ * Pure, so a test can hand it a table whose `defaults.unknown` says
+ * something else. The shipped table says "unknown", which is what the
+ * hardcoded fallback used to be - so a test that only checked the value
+ * could not tell the two apart.
+ *
+ * @param {{ models?: Record<string, RetentionRecord>, defaults?: Record<string, string> }} table
  * @param {string} model
  * @returns {Retention}
  */
-export function modelRetention(model) {
-  const declared = retentionFor(model)?.retention ?? "unknown"
+export function retentionOf(table, model) {
+  const fallback = table?.defaults?.unknown ?? "unknown"
+  const models = table?.models ?? {}
+  const record = models[model] ?? models[model.includes("/") ? model : `opencode/${model}`]
+  const declared = record?.retention ?? fallback
   return /** @type {Retention} */ (
     ["zero-retention", "retained", "may-train", "unknown"].includes(declared)
       ? declared
@@ -319,6 +393,21 @@ export function modelRetention(model) {
   )
 }
 
+/**
+ * The retention of a model id, qualified or not.
+ *
+ * A model with no entry in retention.yml gets the `defaults.unknown` value
+ * from that file, which is `unknown` today. The fallback used to be
+ * hardcoded here, so the `defaults:` block in retention.yml looked like
+ * configuration and was not.
+ *
+ * @param {string} model
+ * @returns {Retention}
+ */
+export function modelRetention(model) {
+  return retentionOf(loadRetention(), model)
+}
+
 /**
  * Whether a model's retention is at or below a ceiling.
  *
@@ -333,8 +422,8 @@ export function modelRetention(model) {
 export function retentionAllowed(model, ceiling) {
   const level = modelRetention(model)
   if (level === "unknown") return false
-  const max = RETENTION_SEVERITY.indexOf(ceiling)
-  const have = RETENTION_SEVERITY.indexOf(level)
+  const max = retentionSeverity(ceiling)
+  const have = retentionSeverity(level)
   if (max < 0) return false
   return have <= max
 }
@@ -363,7 +452,8 @@ export function resolveLaneChain(p, role) {
  *
  * The first rung of the chain that is allowed by the retention ceiling and is
  * not marked unhealthy wins. When no rung qualifies, the lane falls back to
- * the profile's base model, so a lane is never left without a model.
+ * the profile's base model, so a lane is never left without a model - and a
+ * base model that is itself spent is the last resort rather than the first.
  *
  * @param {Profile} p
  * @param {string} role
@@ -378,9 +468,16 @@ export function resolveLaneModel(p, role, opts = {}) {
     if (!retentionAllowed(candidate, ceiling)) continue
     return { model: candidate, levels: levelsOfModel(candidate) }
   }
-  // Nothing in the chain qualifies. Use the first rung anyway rather than
-  // leaving the lane without a model, and let the config header say what the
-  // effective retention turned out to be.
+  // Nothing in the chain qualifies. The base model is the next thing to try:
+  // it is the profile's own route, and a lane pinned to a rung the router has
+  // already recorded as spent is worse than a lane on a route that was never
+  // preferred for this job but is alive.
+  if (p.model && !unhealthy.has(p.model) && retentionAllowed(p.model, ceiling)) {
+    return { model: p.model, levels: levelsOfModel(p.model) }
+  }
+  // Last resort: the first rung anyway rather than leaving the lane without a
+  // model, and let the config header say what the effective retention turned
+  // out to be.
   const fallback = resolveLaneChain(p, role)[0] ?? p.model
   return { model: fallback, levels: levelsOfModel(fallback) }
 }
@@ -471,6 +568,14 @@ export function resolveEffort(levels, requested) {
   if (!levels || levels.length === 0) return null
   if (levels.includes(requested)) return requested
 
+  // `none` is not a rung on the reasoning scale. It is reasoning OFF, and
+  // "off" is not "the lowest level the model has". Snapping it onto `low`
+  // would turn the one lane that exists to stop reasoning into the lane that
+  // reasons the most, and it would do so silently. A model that does not
+  // publish `none` cannot turn reasoning off, so the honest answer is "emit
+  // no variant" and let the model use its own default.
+  if (requested === "none") return null
+
   const want = CANON.indexOf(requested)
   if (want < 0) {
     // Unknown label. Snap to the top level, which is the safe reading of a
@@ -538,6 +643,32 @@ export function validate(p, path = "<memory>") {
       )
     }
   }
+  // The pruning knobs are limits, and a limit of zero or less is not a limit.
+  // `keepRecentTurns: -1` made the prunable span reach the last message,
+  // which is the one message the file's own invariants say never to touch.
+  if (p.prune) {
+    const prune = p.prune
+    if (prune.keepRecentToolCalls !== undefined) {
+      if (!Number.isInteger(prune.keepRecentToolCalls) || prune.keepRecentToolCalls < 1) {
+        throw new ProfileError(
+          `${where}: prune.keepRecentToolCalls must be an integer of at least 1`,
+        )
+      }
+    }
+    if (prune.keepRecentTurns !== undefined) {
+      if (!Number.isInteger(prune.keepRecentTurns) || prune.keepRecentTurns < 1) {
+        throw new ProfileError(
+          `${where}: prune.keepRecentTurns must be an integer of at least 1`,
+        )
+      }
+    }
+    if (prune.keepUserMessages !== undefined && typeof prune.keepUserMessages !== "boolean") {
+      throw new ProfileError(`${where}: prune.keepUserMessages must be a boolean`)
+    }
+    if (prune.enabled !== undefined && typeof prune.enabled !== "boolean") {
+      throw new ProfileError(`${where}: prune.enabled must be a boolean`)
+    }
+  }
   for (const [role, rm] of Object.entries(p.roleModels ?? {})) {
     if (!LANE_NAMES.includes(role)) {
       throw new ProfileError(
@@ -554,9 +685,13 @@ export function validate(p, path = "<memory>") {
     if (!rm?.model || typeof rm.model !== "string") {
       throw new ProfileError(`${where}: roleModels.${role} needs a model`)
     }
-    if (rm.levels !== undefined && !Array.isArray(rm.levels)) {
+    if (rm.levels !== undefined) {
+      // The field used to be in the schema and validated as an array, and
+      // then nothing read it. A profile author could fill it with a lie and
+      // get no error. It is out of the schema now, and a profile that still
+      // carries it is told so rather than having it ignored.
       throw new ProfileError(
-        `${where}: roleModels.${role}.levels must be an array`,
+        `${where}: roleModels.${role}.levels is not read by anything - the lane takes its levels from the model it runs on. Remove it.`,
       )
     }
     if (rm.chain !== undefined) {
@@ -576,6 +711,15 @@ export function validate(p, path = "<memory>") {
             `${where}: roleModels.${role}.chain names ${rung}, which has no retention.yml entry`,
           )
         }
+        // A rung with no profile cannot be resolved: its levels are unknown
+        // and its limits are unknown, so the lane quietly runs on a model it
+        // did not ask for. The retention check above passed it, because
+        // retention.yml lists a few paid routes the kit has no profile for.
+        if (!profileExists(rung)) {
+          throw new ProfileError(
+            `${where}: roleModels.${role}.chain names ${rung}, which has no profile in this directory`,
+          )
+        }
       }
     }
     // retention.yml is the only place retention is decided, so a role model
@@ -585,9 +729,61 @@ export function validate(p, path = "<memory>") {
         `${where}: roleModels.${role} names ${rm.model}, which has no retention.yml entry`,
       )
     }
+    if (!profileExists(rm.model)) {
+      throw new ProfileError(
+        `${where}: roleModels.${role} names ${rm.model}, which has no profile in this directory`,
+      )
+    }
+  }
+  // The utility route has to be a model this profile can actually run, or a
+  // failover leaves opencode's short auxiliary calls pointing at a model that
+  // is not in the fleet.
+  //
+  // The check is STATIC - the union of the profile's own model and every
+  // model its chains name. Asking `modelsInPlay` would be the obvious way,
+  // and it is a loop: resolving a lane reads the levels of a model, which
+  // loads that model's profile, which validates it, which resolves a lane.
+  if (p.utility) {
+    if (typeof p.utility.model !== "string" || !p.utility.model) {
+      throw new ProfileError(`${where}: utility.model must be a model id`)
+    }
+    const reachable = new Set([p.model])
+    for (const rm of Object.values(p.roleModels ?? {})) {
+      if (rm?.model) reachable.add(rm.model)
+      for (const rung of rm?.chain ?? []) reachable.add(rung)
+    }
+    if (!reachable.has(p.utility.model)) {
+      throw new ProfileError(
+        `${where}: utility.model is ${p.utility.model}, which this profile does not resolve to (it has ${[...reachable].join(", ")})`,
+      )
+    }
+  }
+
+  // The fallback queue is walked at startup, and an id that does not resolve
+  // is skipped without a word - so the queue quietly shortens and the
+  // session stays on a route that is already spent.
+  for (const id of p.fallback ?? []) {
+    if (!profileExists(id)) {
+      throw new ProfileError(
+        `${where}: fallback names ${id}, which has no profile in this directory`,
+      )
+    }
   }
 }
 
+/**
+ * Whether a model id has a profile in this directory.
+ *
+ * The file is looked for rather than loaded: `loadProfile` validates, and
+ * validation is what asks this question.
+ *
+ * @param {string} id
+ * @returns {boolean}
+ */
+function profileExists(id) {
+  return profilePath(id) !== null
+}
+
 // --- context sizing ---------------------------------------------------------
 
 /**
@@ -697,7 +893,7 @@ export function effectiveRetention(p, opts = {}) {
     const declared = modelRetention(id)
     if (
       !worst ||
-      RETENTION_SEVERITY.indexOf(declared) > RETENTION_SEVERITY.indexOf(retention)
+      retentionSeverity(declared) > retentionSeverity(retention)
     ) {
       worst = id
       retention = declared
@@ -710,8 +906,11 @@ export function effectiveRetention(p, opts = {}) {
 
 /** Where opencode keeps its config, honouring the same env var it does. */
 export function configDir() {
+  // `homedir()` and not `process.env.HOME`: with HOME unset the other form
+  // produced a RELATIVE path, so `use` wrote to one place and
+  // `profileIdFromConfig` read another.
   return (
-    process.env.OPENCODE_CONFIG_DIR ?? join(process.env.HOME ?? "", ".config", "opencode")
+    process.env.OPENCODE_CONFIG_DIR ?? join(homedir(), ".config", "opencode")
   )
 }
 

package/src/project.js

@@ -0,0 +1,47 @@
+// Where the kit's files live, and where its scope ends.
+//
+// `ctx.worktree` is opencode's WORKTREE: the git root of the project. For a
+// directory that is not a git repository it is the FILESYSTEM ROOT, which is
+// not a place to write a project's telemetry.
+//
+// That was not visible from the code, because the kit only ever ran in git
+// repositories. In every other project the config hook's write to
+// `.space/active` failed with a permission error that the plugin swallowed,
+// so:
+//
+//   - the pruner never found an active profile and did nothing at all,
+//   - the router never recorded a spent route, so no lane ever failed over,
+//   - the telemetry wrote to a place nobody looks.
+//
+// The session's own DIRECTORY is the reliable answer: it is where the user is
+// working, and it is set for every session. The git root is preferred when
+// there is one, because a project's files live there and a subdirectory of a
+// monorepo is not the project.
+
+import { existsSync } from "node:fs"
+import { dirname, join, resolve } from "node:path"
+
+/**
+ * The root of the project a session is working in.
+ *
+ * @param {string | null | undefined} directory the session's working directory
+ * @param {string | null | undefined} worktree opencode's worktree, as a fallback
+ * @returns {string}
+ */
+export function projectRoot(directory, worktree) {
+  const start = resolve(directory || worktree || ".")
+  let dir = start
+  // The walk is bounded by the filesystem, not by a number: a session more
+  // than a dozen directories below the git root is a monorepo, and a cap
+  // that stops early would put the kit's files in a subdirectory.
+  for (let i = 0; i < 64; i++) {
+    if (existsSync(join(dir, ".git"))) return dir
+    const parent = dirname(dir)
+    if (parent === dir) break
+    dir = parent
+  }
+  // No git root anywhere above: the session's own directory is the project.
+  // The worktree is deliberately NOT used here - in a non-git project it is
+  // the filesystem root.
+  return start
+}

package/src/prune.ts

@@ -16,23 +16,26 @@
 //   - never touch patch or file parts, which carry diffs the model needs
 //   - never stub a user message unless asked to
 
-import type { Plugin } from "@opencode-ai/plugin"
+import type { Plugin } from "./plugin.js"
 import { loadProfile, pruneThreshold, ROOT } from "./profile.js"
+import { projectRoot } from "./project.js"
 import { readFileSync, existsSync } from "node:fs"
 import { join } from "node:path"
 
 /**
- * Which profile is active. In order: an explicit environment variable, the
- * marker the plugin writes into the project, then a marker inside the package.
+ * Which profile is active. In order: an explicit environment variable, then the
+ * marker the config hook writes into the project.
  * Returns null when nothing is set, and pruning then stays off rather than
  * guessing at thresholds.
  */
 function activeProfileId(worktree: string): string | null {
-  const candidates = [
-    process.env.OPENCODE_HARNESS_PROFILE,
-    join(worktree, ".space", "active"),
-    join(ROOT, "profiles", ".active"),
-  ]
+  // The environment variable is a PROFILE ID, not a path.
+  //
+  // It was being checked with existsSync, like the marker below it, so it
+  // never matched a file and the documented override had never worked.
+  const fromEnv = process.env.OPENCODE_HARNESS_PROFILE
+  if (fromEnv && fromEnv.trim()) return fromEnv.trim()
+  const candidates = [join(worktree, ".space", "active")]
   for (const f of candidates) {
     if (!f) continue
     try {
@@ -47,6 +50,15 @@ function activeProfileId(worktree: string): string | null {
   return null
 }
 
+/**
+ * What an old reasoning part is replaced with.
+ *
+ * Short, and it says what happened: the model should not go looking for the
+ * reasoning it can no longer see.
+ */
+const REASONING_STUB =
+  "[reasoning] dropped from context - it was from an earlier turn and is stale."
+
 interface StubStats {
   stubbed: number
   kept: number
@@ -56,6 +68,10 @@ interface StubStats {
 
 /** Rough size of a part, used only for the stats line. */
 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
+  // any text that is not ASCII - which is most of the code in a repository.
+  // The field is named for what it measures.
   if (typeof part?.text === "string") return part.text.length
   if (typeof part?.state?.output === "string") return part.state.output.length
   return 0
@@ -76,7 +92,10 @@ function stub(part: any): string {
     const status = state.status ?? "done"
     let tail = ""
     const out = String(state.output ?? "")
-    const m = out.match(/(passed|failed|error|Error|ok|OK|\d+ (?:passed|failed))/g)
+    // Whole words only. The pattern used to match "ok" anywhere, so a command
+    // whose output contained "took 3 seconds" was reported as "ok" - a
+    // passing verdict that was never observed.
+    const m = out.match(/\b(?:\d+\s+(?:passed|failed)|passed|failed|error|ok)\b/gi)
     if (m && m.length) tail = `, ${m[m.length - 1]}`
     return `[${tool}] ${cmd} -> ${status}${tail} | full output was pruned from context; re-run the command if you need it`
   }
@@ -87,28 +106,67 @@ function stub(part: any): string {
   return `[${tool}] result pruned from context (${state.status ?? "done"}); re-run if you need it`
 }
 
-export const PrunePlugin: Plugin = async ({ worktree, $ }) => {
-  let profile = null as ReturnType<typeof loadProfile> | null
-  try {
-    const id = activeProfileId(worktree)
-    if (id) profile = loadProfile(id)
-  } catch {
-    profile = null
+export const PrunePlugin: Plugin = async ({ worktree, directory }) => {
+  // The project root, not the worktree: in a project that is not a git
+  // repository the worktree is the filesystem root, so the marker the pruner
+  // reads was never where it looked, and the pruner did nothing.
+  const project = projectRoot(directory, worktree)
+  // The profile is resolved on the FIRST TRANSFORM, not here.
+  //
+  // OpenCode builds the plugin factories before it runs the config hooks, and
+  // the config hook is what writes the marker file naming the active profile.
+  // Resolving here meant a fresh project had no marker yet, so pruning was
+  // off for that entire first session - and a project switched to another
+  // profile kept pruning with the previous one's thresholds for one more
+  // session.
+  //
+  // The hook is therefore always registered, and the decision to prune is made
+  // per request. Pruning is opt-in per profile: with no active profile, or a
+  // profile that does not enable it, nothing is touched.
+  type Resolved = {
+    profile: any
+    keepCalls: number
+    keepTurns: number
+    keepUsers: boolean
+    threshold: number
   }
-  if (!profile?.prune?.enabled) {
-    // Pruning is opt-in per profile. With no active profile we do nothing
-    // rather than guess at thresholds.
-    return {}
+  const DISABLED: Resolved = {
+    profile: null,
+    keepCalls: 0,
+    keepTurns: 0,
+    keepUsers: true,
+    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
 
-  const keepCalls = profile.prune.keepRecentToolCalls ?? 6
-  const keepTurns = profile.prune.keepRecentTurns ?? 3
-  const keepUsers = profile.prune.keepUserMessages ?? true
-  const threshold = pruneThreshold(profile)
+  const resolve = (): Resolved => {
+    if (cached) return cached
+    let profile = null as ReturnType<typeof loadProfile> | null
+    try {
+      const id = activeProfileId(project)
+      if (id) profile = loadProfile(id)
+    } catch {
+      profile = null
+    }
+    if (!profile?.prune?.enabled) return DISABLED
+    cached = {
+      profile,
+      keepCalls: profile.prune.keepRecentToolCalls ?? 6,
+      keepTurns: profile.prune.keepRecentTurns ?? 3,
+      keepUsers: profile.prune.keepUserMessages ?? true,
+      threshold: pruneThreshold(profile),
+    }
+    return cached
+  }
 
   return {
-    "experimental.chat.messages.transform": async (_input, output) => {
+    "experimental.chat.messages.transform": async (_input: any, output: any) => {
       try {
+        const { profile, keepCalls, keepTurns, keepUsers, threshold } = resolve()
+        if (!profile) return
         const messages = output.messages
         if (!Array.isArray(messages) || messages.length === 0) return
 
@@ -165,11 +223,25 @@ export const PrunePlugin: Plugin = async ({ worktree, $ }) => {
                 stats.bytesAfter += size
                 stats.kept++
                 break
-              case "reasoning":
-                // Old reasoning is stale by definition and safe to drop.
-                stats.bytesAfter += Math.min(size, 200)
+              case "reasoning": {
+                // Old reasoning is stale by definition and safe to drop, and
+                // it IS dropped.
+                //
+                // The part used to keep its full text while the stats booked
+                // 200 bytes "after" for it. The reported saving therefore
+                // included bytes that were never removed - and reasoning is
+                // 15.6% of stored bytes, so the number was not a rounding
+                // error.
+                //
+                // The part keeps its shape: a reasoning part in the OpenCode
+                // part schema has no signature, so replacing its text is
+                // safe. A part that grew one would have to be removed rather
+                // than rewritten.
+                part.text = REASONING_STUB
+                stats.bytesAfter += sizeOf(part)
                 stats.stubbed++
                 break
+              }
               case "tool": {
                 // Only completed calls carry an output worth pruning. Pending
                 // and running states are small, and error states are usually
@@ -207,7 +279,7 @@ export const PrunePlugin: Plugin = async ({ worktree, $ }) => {
 
         if (stats.stubbed > 0) {
           const saved = Math.max(0, stats.bytesBefore - stats.bytesAfter)
-          await logPrune(profile.id, {
+          await logPrune(project, profile.id, {
             ...stats,
             saved,
             threshold,
@@ -227,13 +299,20 @@ export const PrunePlugin: Plugin = async ({ worktree, $ }) => {
 }
 
 async function logPrune(
+  worktree: string,
   profileId: string,
   stats: StubStats & {
     saved: number
     threshold: number
   },
 ) {
-  const dir = join(process.cwd(), ".space")
+  // The WORKTREE, not `process.cwd()`. Every other writer in this kit uses
+  // the worktree, and the plugin's worktree is the project. The process cwd
+  // is wherever opencode happened to be started from, which is often the
+  // user's home directory - so the log landed outside the project, in a
+  // directory no project-scoped tool looks at, and two projects sharing a cwd
+  // shared one log.
+  const dir = join(worktree, ".space")
   try {
     const { mkdir, appendFile } = await import("node:fs/promises")
     await mkdir(dir, { recursive: true })
@@ -244,7 +323,7 @@ async function logPrune(
         profile: profileId,
         stubbed: stats.stubbed,
         kept: stats.kept,
-        savedBytes: stats.saved,
+        savedChars: stats.saved,
         threshold: stats.threshold,
       }) + "\n",
     )