opencode-harness-kit 0.6.3 → 0.7.0

package/src/budget.js

@@ -0,0 +1,418 @@
+// The token budget: per session, and across the sessions that share a window.
+//
+// The free tier is a shared window: every request in every session draws on
+// it, and when it runs out the provider answers with a limit error instead of
+// tokens. Nothing in opencode counts the window, so a long chat session can
+// spend it without ever showing a number - one real session made 599 requests
+// and 12,025,980 input tokens, and the first sign of trouble was the provider
+// refusing the next one.
+//
+// This is the counter. It counts the context a request re-sent: the uncached
+// input, plus the prompt cache it read, plus the cache it wrote. That is the
+// number the provider's window is spent on, and it is NOT `tokens.input`:
+// with prompt caching the uncached part is a few hundred tokens against tens
+// of thousands of `cache.read`, so a counter built on `input` alone undercounts
+// a real session by five to forty times and never fires. Output is capped by the
+// model and is a small fraction of the bill, so it is not counted.
+//
+// The limits are environment variables, not config keys: the guard runs
+// inside opencode, and the environment is the one thing that reaches it
+// without a round trip through the config file.
+//
+//   OC_HARNESS_BUDGET_WARN   warn once at this many context tokens (default 2M)
+//   OC_HARNESS_BUDGET_STOP   block tool calls at this many (default 5M)
+//   OC_HARNESS_TURN_STOP     block after one request re-sent this much
+//                            (default 300k): the count that catches a loop the
+//                            per-session total is too large to catch
+//
+// and, for the window every session shares:
+//
+//   OC_HARNESS_BUDGET_WINDOW_MINUTES  how far back to sum (default 60)
+//   OC_HARNESS_BUDGET_WINDOW_WARN     warn once at this many (default 4M)
+//   OC_HARNESS_BUDGET_WINDOW_STOP     block tool calls at this many (default 8M)
+//   OC_HARNESS_BUDGET_WINDOW_STICKY   `0` lets a stop end when the sum rolls
+//                                     over; default on holds it for 6h
+//   OC_HARNESS_BUDGET_FILE            the ledger path (tests, benchmarks)
+//
+// Zero disables that threshold. A stop below the warn is not a warn: the warn
+// is clamped down to the stop, so the warning always comes first.
+
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs"
+import { homedir } from "node:os"
+import { dirname, join } from "node:path"
+
+export const DEFAULT_WARN_TOKENS = 2_000_000
+export const DEFAULT_STOP_TOKENS = 5_000_000
+
+// What one request may re-send before it is a loop rather than a turn. A
+// request that re-sends 58,000 tokens costs the same on its fifth retry as on
+// its first, so the per-session total above does not see a loop until it has
+// spent far more than a person can use: the session that prompted this kit
+// made 599 requests at 20,077 tokens each. The per-turn count stops the loop
+// while the ledger still has room, and it is counted PER SESSION, not from the
+// shared ledger: one step-finish reports one request's context, and the
+// ledger's sum over an hour is a different number.
+export const DEFAULT_TURN_STOP_TOKENS = 300_000
+
+// The provider's window is not per session and not per project: every session
+// on the account draws on the same one, and it is what actually runs out. A
+// per-session count cannot see that - three parallel sessions each under their
+// own stop still spend three times the budget. These defaults are the shared
+// tripwire, kept in a file every session reads and appends to.
+export const DEFAULT_WINDOW_MINUTES = 60
+export const DEFAULT_WINDOW_WARN_TOKENS = 4_000_000
+export const DEFAULT_WINDOW_STOP_TOKENS = 8_000_000
+
+/**
+ * A whole, non-negative token count, or the fallback.
+ *
+ * @param {any} raw
+ * @param {number} fallback
+ * @returns {number}
+ */
+function count(raw, fallback) {
+  if (raw === undefined || raw === null || raw === "") return fallback
+  const n = Number(raw)
+  if (!Number.isFinite(n) || n < 0) return fallback
+  return Math.floor(n)
+}
+
+/**
+ * What one request cost, in context tokens.
+ *
+ * A `step-finish` part reports four separate numbers: `input` is the part of
+ * the prompt that was not cached, `cache.read` is the cached prefix the model
+ * still had to read, `cache.write` is the prefix stored for the next request,
+ * and `output`/`reasoning` are what the model wrote. The first three are the
+ * context; only the first was counted before, which is why a step that cost
+ * 37,324 tokens was recorded as 844.
+ *
+ * `cache.write` is charged once, on the request that stored it, so summing it
+ * here is not double counting the reads that follow. Nor does it overlap
+ * `input`: across 605 measured steps the reported `total` was exactly
+ * `input + cache.read + cache.write + output + reasoning` every time, so the
+ * parts are disjoint and the three that are counted are the whole context.
+ *
+ * A value that is not a number contributes zero: a missing field must not turn
+ * the whole count into NaN, because a NaN comparison never fires a threshold.
+ *
+ * @param {any} tokens a `step-finish` part's `tokens`
+ * @returns {number}
+ */
+export function requestTokens(tokens) {
+  /** @param {unknown} raw @returns {number} */
+  const n = (raw) => {
+    const x = Number(raw)
+    return Number.isFinite(x) && x > 0 ? Math.floor(x) : 0
+  }
+  return n(tokens?.input) + n(tokens?.cache?.read) + n(tokens?.cache?.write)
+}
+
+/**
+ * The limits this process should use.
+ *
+ * @param {Record<string, string | undefined>} [env]
+ * @returns {{ warnAt: number, stopAt: number, turnStopAt: number }}
+ */
+export function budgetLimits(env = process.env) {
+  const warnAt = count(env?.OC_HARNESS_BUDGET_WARN, DEFAULT_WARN_TOKENS)
+  const stopAt = count(env?.OC_HARNESS_BUDGET_STOP, DEFAULT_STOP_TOKENS)
+  const turnStopAt = count(env?.OC_HARNESS_TURN_STOP, DEFAULT_TURN_STOP_TOKENS)
+  return {
+    warnAt: stopAt > 0 && warnAt > stopAt ? stopAt : warnAt,
+    stopAt,
+    turnStopAt,
+  }
+}
+
+/**
+ * A running total for one session.
+ *
+ * `add` returns the thresholds this call CROSSED, so the caller can warn once
+ * rather than once per request. A request that lands exactly on a threshold
+ * crosses it, and a request of zero tokens - a retry that never reached the
+ * provider - moves nothing.
+ *
+ * @param {{ warnAt?: number, stopAt?: number }} [limits]
+ */
+export function createBudget({ warnAt = DEFAULT_WARN_TOKENS, stopAt = DEFAULT_STOP_TOKENS } = {}) {
+  let total = 0
+  let warned = false
+  let stopped = false
+
+  return {
+    /**
+     * @param {any} input tokens this request cost
+     * @returns {{ warn: boolean, stop: boolean }}
+     */
+    add(input) {
+      const n = Number(input)
+      if (!Number.isFinite(n) || n <= 0) return { warn: false, stop: false }
+      total += Math.floor(n)
+      let warn = false
+      let stop = false
+      if (!warned && warnAt > 0 && total >= warnAt) {
+        warned = true
+        warn = true
+      }
+      if (!stopped && stopAt > 0 && total >= stopAt) {
+        stopped = true
+        stop = true
+      }
+      return { warn, stop }
+    },
+    get total() {
+      return total
+    },
+    get warned() {
+      return warned
+    },
+    get stopped() {
+      return stopped
+    },
+  }
+}
+
+/**
+ * A count with separators, for a message a human reads.
+ *
+ * @param {number} n
+ * @returns {string}
+ */
+export function tokens(n) {
+  return Math.floor(n).toLocaleString("en-US")
+}
+
+// --- the shared window ------------------------------------------------------
+//
+// A file, not memory: the sessions that share the window are separate
+// processes, and the one that has to warn is often not the one that spent.
+// The file is a list of `{ t, n }` entries, pruned to the longest window any
+// caller asks about, and written by rename so a reader never sees half a line.
+
+/** How long an entry is kept, regardless of the window being asked about. */
+const KEEP_MS = 6 * 60 * 60 * 1000
+
+/**
+ * Where the shared ledger lives.
+ *
+ * `XDG_STATE_HOME` is the right place for state that survives a reboot and is
+ * not configuration; falling back to `~/.local/state` is what the spec says to
+ * do. `OC_HARNESS_BUDGET_FILE` overrides both, which is what the tests use and
+ * what a user on a shared account would want.
+ *
+ * @param {Record<string, string | undefined>} [env]
+ * @returns {string}
+ */
+export function ledgerPath(env = process.env) {
+  const override = env?.OC_HARNESS_BUDGET_FILE
+  if (override) return override
+  const state = env?.XDG_STATE_HOME || join(env?.HOME || homedir(), ".local", "state")
+  return join(state, "opencode-harness-kit", "budget.json")
+}
+
+/**
+ * The entries in the ledger, or none.
+ *
+ * Three answers, not two, because "I could not read the count" and "the count
+ * is zero" are different facts and only one of them means there is room left:
+ *
+ *   - no file            -> `[]`: nothing has been spent yet.
+ *   - a file that parses -> its entries.
+ *   - a file that does not parse -> `null`.
+ *
+ * It used to return `[]` for the third case, which made a corrupt or
+ * half-written ledger indistinguishable from an empty window: the shared stop
+ * silently disappeared. `sharedWindowSpent()` in `guard.ts` repairs the file
+ * instead (see `repairSpend`): a ledger that cannot be read must not lock the
+ * window forever, because the only way out is a hand-delete the user may not
+ * know about. Nothing here throws.
+ *
+ * A `stop` entry is a marker, not a spend: `{ t, n: 0, stop: true }` records
+ * that the window was locked at `t`, so the lock can outlive the sliding sum
+ * that tripped it.
+ *
+ * @param {string} path
+ * @returns {{ t: number, n: number, stop?: boolean }[] | null}
+ */
+export function readSpend(path) {
+  let raw
+  try {
+    if (!existsSync(path)) return []
+    raw = readFileSync(path, "utf8")
+  } catch {
+    return null
+  }
+  let parsed
+  try {
+    parsed = JSON.parse(raw)
+  } catch {
+    return null
+  }
+  if (!Array.isArray(parsed)) return null
+  return parsed.filter(
+    (e) =>
+      e &&
+      Number.isFinite(e.t) &&
+      Number.isFinite(e.n) &&
+      (e.n > 0 || (e.stop === true && e.n === 0)),
+  )
+}
+
+/**
+ * Keep the entries that are still inside the keep window, oldest first.
+ *
+ * @param {{ t: number, n: number, stop?: boolean }[]} entries
+ * @param {number} now
+ * @returns {{ t: number, n: number, stop?: boolean }[]}
+ */
+export function pruneSpend(entries, now) {
+  const floor = now - KEEP_MS
+  return entries.filter((e) => e.t >= floor).sort((a, b) => a.t - b.t)
+}
+
+/**
+ * Move an unreadable ledger aside and start a fresh one.
+ *
+ * The old code read a corrupt file as "spent" and failed closed, which is the
+ * right answer for a single tool call and the wrong answer for the machine:
+ * the only exit was deleting a file the user had never heard of, so the next
+ * session was blocked for six hours by a truncated JSON write. The evidence
+ * still matters - a corrupt ledger is a bug worth reading - so the broken file
+ * is renamed to `<path>.corrupt` rather than deleted, and an empty ledger
+ * replaces it. The count cannot be recovered, so the new file starts at zero;
+ * if the old file had a stop marker, `.corrupt` still holds it.
+ *
+ * Returns false when the repair could not be written; the caller then falls
+ * back to the old fail-closed answer rather than pretending the window is
+ * empty.
+ *
+ * @param {string} path
+ * @returns {boolean}
+ */
+export function repairSpend(path) {
+  try {
+    if (existsSync(path)) renameSync(path, `${path}.corrupt`)
+    writeSpend(path, [])
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Write the ledger, atomically.
+ *
+ * Read-modify-write without a lock: two sessions finishing a step in the same
+ * millisecond can lose one entry. That is a few thousand tokens on a budget of
+ * millions, and a lock file in this path is a worse failure mode - a crashed
+ * session would leave the window blocked for everyone.
+ *
+ * @param {string} path
+ * @param {{ t: number, n: number, stop?: boolean }[]} entries
+ */
+export function writeSpend(path, entries) {
+  const tmp = `${path}.${process.pid}.tmp`
+  mkdirSync(dirname(path), { recursive: true })
+  writeFileSync(tmp, JSON.stringify(entries))
+  renameSync(tmp, path)
+}
+
+/**
+ * Add one request's cost to the shared ledger.
+ *
+ * A ledger that cannot be read is repaired first, so the first write after a
+ * corruption appends to a fresh file instead of overwriting the broken one.
+ * The repair does not invent a stop: the count is unknown, and a marker that
+ * holds for six hours is the failure this repair exists to end.
+ *
+ * @param {string} path
+ * @param {number} n
+ * @param {number} [now]
+ * @returns {{ t: number, n: number, stop?: boolean }[]} the pruned ledger
+ */
+export function recordSpend(path, n, now = Date.now()) {
+  const previous = readSpend(path)
+  if (previous === null) repairSpend(path)
+  const entries = pruneSpend(previous ?? [], now)
+  if (Number.isFinite(n) && n > 0) entries.push({ t: now, n: Math.floor(n) })
+  writeSpend(path, entries)
+  return entries
+}
+
+/**
+ * Record that the window was locked, so the lock survives the window it was
+ * measured in.
+ *
+ * The sum is over the last hour, and the provider's window is not: it stayed
+ * shut for hours after the stop fired. A lock that releases itself on a timer
+ * is a lock that was only partly on, so the marker holds until `KEEP_MS`.
+ *
+ * @param {string} path
+ * @param {number} [now]
+ * @returns {{ t: number, n: number, stop?: boolean }[]} the pruned ledger
+ */
+export function recordStop(path, now = Date.now()) {
+  const previous = readSpend(path)
+  if (previous === null) repairSpend(path)
+  const entries = pruneSpend(previous ?? [], now)
+  entries.push({ t: now, n: 0, stop: true })
+  writeSpend(path, entries)
+  return entries
+}
+
+/**
+ * Whether a stop marker is still inside the keep window.
+ *
+ * @param {{ t: number, n: number, stop?: boolean }[]} entries
+ * @param {number} now
+ * @returns {boolean}
+ */
+export function stopRecorded(entries, now) {
+  const floor = now - KEEP_MS
+  return entries.some((e) => e.stop === true && e.t >= floor)
+}
+
+/**
+ * Tokens spent in the last `windowMs`, across every session on this machine.
+ *
+ * @param {{ t: number, n: number, stop?: boolean }[]} entries
+ * @param {number} now
+ * @param {number} windowMs
+ * @returns {number}
+ */
+export function windowSpend(entries, now, windowMs) {
+  const floor = now - windowMs
+  let total = 0
+  for (const e of entries) if (e.t >= floor) total += e.n
+  return total
+}
+
+/**
+ * The shared-window thresholds.
+ *
+ * `OC_HARNESS_BUDGET_WINDOW_MINUTES` sets the window (default 60). Zero or a
+ * value that is not a positive number falls back to the default: a window of
+ * zero would sum nothing and silently disable the tripwire.
+ *
+ * `OC_HARNESS_BUDGET_WINDOW_STICKY` (default on) makes a stop hold until its
+ * marker ages out, instead of ending when the entries that tripped it roll out
+ * of the window. `0` restores the sum-only behaviour, which unlocks the
+ * window on a timer the provider does not keep.
+ *
+ * @param {Record<string, string | undefined>} [env]
+ * @returns {{ windowMs: number, warnAt: number, stopAt: number, sticky: boolean }}
+ */
+export function windowLimits(env = process.env) {
+  const rawMinutes = Number(env?.OC_HARNESS_BUDGET_WINDOW_MINUTES)
+  const minutes =
+    Number.isFinite(rawMinutes) && rawMinutes > 0 ? Math.floor(rawMinutes) : DEFAULT_WINDOW_MINUTES
+  const warnAt = count(env?.OC_HARNESS_BUDGET_WINDOW_WARN, DEFAULT_WINDOW_WARN_TOKENS)
+  const stopAt = count(env?.OC_HARNESS_BUDGET_WINDOW_STOP, DEFAULT_WINDOW_STOP_TOKENS)
+  return {
+    windowMs: minutes * 60_000,
+    warnAt: stopAt > 0 && warnAt > stopAt ? stopAt : warnAt,
+    stopAt,
+    sticky: env?.OC_HARNESS_BUDGET_WINDOW_STICKY !== "0",
+  }
+}

package/src/config.js

@@ -29,8 +29,8 @@ import {
   loadLanes,
 } from "./profile.js"
 
-import { join } from "node:path"
-import { readFileSync } from "node:fs"
+import { join, resolve } from "node:path"
+import { existsSync, readFileSync } from "node:fs"
 import { homedir } from "node:os"
 import { BASH_DENYLIST } from "./denylist.js"
 
@@ -79,6 +79,61 @@ export function kitVersion() {
   }
 }
 
+/** Where opencode's user config lives when nothing overrides it. */
+export const DEFAULT_CONFIG_DIR = join(homedir(), ".config/opencode")
+
+/** Where this kit itself lives - the parent of the bundle (or src) directory. */
+export function kitRoot() {
+  // `../package.json` from the module's own location is exactly where
+  // kitVersion() reads the version from: in dev, `../` of src/; in a bundle,
+  // `../` of dist/. Either way it is the kit's root, which is the right
+  // second base for a relative skills path that points INTO the kit.
+  return new URL("..", import.meta.url).pathname
+}
+
+/**
+ * The skills.paths entries of a base config, with the dead ones dropped.
+ *
+ * A `paths` entry that never resolves is not a configuration - it is noise
+ * the file carries for every reader to puzzle over, and a reader who DOES
+ * puzzle over it gets a wrong model of the world: this kit's config shipped
+ * `["../skills"]` which had dl resolved to `~/.config/skills` - a directory
+ * that has never existed on this machine - for release after release.
+ *
+ * A relative entry resolves against the opencode config directory; an
+ * absolute one stands as written; a relative one is also checked against the
+ * kit root, because an entry pointing INTO the kit was always a plausible
+ * intent and the kit knows where its own skills are. Nothing that resolves
+ * is kept; word everything else is dropped and named in the header, the same
+ * way dropped bash rules and removed lanes are.
+ *
+ * @param {any} skills
+ * @param {string} configDir
+ * @param {string} [kitRoot] where the kit itself lives, when overridable
+ * @returns {{ skills: any, dropped: string[] }}
+ */
+export function cleanSkillPaths(skills, configDir, kitRoot) {
+  const paths = skills?.paths
+  if (!Array.isArray(paths) || !paths.length) return { skills, dropped: [] }
+  const kept = []
+  const dropped = []
+  for (const p of paths) {
+    if (typeof p !== "string" || !p.trim()) {
+      dropped.push(String(p))
+      continue
+    }
+    const candidates =
+      p.startsWith("/") || p.startsWith("~") ? [p] : [resolve(configDir, p), ...(kitRoot ? [resolve(kitRoot, p)] : [])]
+    const live = candidates.some((c) => {
+      const real = c.startsWith("~") ? join(homedir(), c.slice(1)) : c
+      return existsSync(real)
+    })
+    if (live) kept.push(p)
+    else dropped.push(p)
+  }
+  return { skills: { ...skills, paths: kept }, dropped }
+}
+
 /**
  * The memory plugin this kit can turn on.
  *
@@ -316,7 +371,8 @@ function userBashRules(base) {
 
 /**
  * @param {Profile} p
- * @param {{ base?: Record<string, any>, comments?: boolean, unhealthy?: Set<string> }} [opts]
+ * @param {{ base?: Record<string, any>, comments?: boolean, unhealthy?: Set<string>,
+ *          configDir?: string, kitRoot?: string, skills?: boolean }} [opts]
  * @returns {string}
  */
 export function generateConfig(p, opts = {}) {
@@ -359,6 +415,16 @@ export function generateConfig(p, opts = {}) {
           ...lane.permission,
         }
       }
+      // The skill list is the largest fixed cost in the prompt. opencode
+      // writes every discovered skill's name and description into the system
+      // message, so a machine with a large skill collection pays it on every
+      // request, before a word of the conversation - and a long chat pays it
+      // hundreds of times. The lanes carry their instructions in prompts/, so
+      // `--no-skills` omits the block for them; `skills: true` on a lane keeps
+      // it for that lane, and nothing changes when the flag is not passed.
+      if (opts.skills === false && lane.skills !== true) {
+        existing.tools = { ...(existing.tools ?? {}), skill: false }
+      }
     }
 
     // A primary agent may hand work to a lane. The rule is per-agent, and it
@@ -373,6 +439,50 @@ export function generateConfig(p, opts = {}) {
     agent[role] = existing
   }
 
+  // A lane the profile no longer manages gets no pin from the loop above -
+  // the loop only walks the profile's own roles - so a fleet lane left over
+  // from a previous profile survived every later `oc-harness use`, still
+  // carrying the previous profile's pinned model and kit prompt, and a model
+  // that may no longer match the file's retention header.
+  //
+  // The entry is removed only when the KIT still owns it: its prompt is the
+  // compiler's own lane file. An entry a user has rewritten - a different
+  // prompt file, or no prompt at all - is user data, and it is left alone:
+  // dropping it here would delete work a `use` cannot recreate.
+  //
+  // Every removal is named in the header alongside the dropped bash rules.
+  const removedLanes = []
+  for (const name of Object.keys(agent)) {
+    if (roles[name] !== undefined) continue
+    if (!lanes[name]) continue
+    const prompt = agent[name]?.prompt
+    if (typeof prompt === "string" && prompt.endsWith(`/prompts/${name}.md}`)) {
+      delete agent[name]
+      removedLanes.push(name)
+    }
+  }
+
+  // A second bundle hid in the same map: the ECC subagents, whose prompts
+  // live at `prompts/agents/<name>.txt`. They are not lanes, so the loop
+  // above ignored them, and the live config carried 25 of them - architect,
+  // code-reviewer, e2e-runner and the rest. Their descriptions are loaded on
+  // every request, which is the 6k-token floor this removes; their prompts
+  // are read only when one is delegated to.
+  //
+  // Ownership is the same rule as above: only an entry whose prompt is the
+  // bundle's own `{file:...prompts/agents/<name>.txt}` is removed. An agent
+  // the user wrote, or a lane, is untouched.
+  const removedBundled = []
+  for (const name of Object.keys(agent)) {
+    if (roles[name] !== undefined) continue
+    if (lanes[name]) continue
+    const prompt = agent[name]?.prompt
+    if (typeof prompt === "string" && /\{file:[^}]*prompts\/agents\/[^}]+\}/.test(prompt)) {
+      delete agent[name]
+      removedBundled.push(name)
+    }
+  }
+
   // The user's own bash rules are merged in, not replaced.
   //
   // The map used to be built from the kit's two lists alone, so every rule
@@ -423,6 +533,15 @@ export function generateConfig(p, opts = {}) {
   delete base_.variant
   delete base_.tool_output
 
+  // The skills paths are cleaned before the config is built, so the header
+  // can name what was dropped: a dead entry is dropped from the file and
+  // announced, the same way dropped bash rules and removed lanes are. The
+  // kit root comes from the bundle's own location - the same place
+  // kitVersion() reads its package.json from - so a relative entry pointing
+  // INTO the kit ("skills", "./skills") also stays alive.
+  const configDir = opts.configDir ?? DEFAULT_CONFIG_DIR
+  const skillPaths = cleanSkillPaths(base.skills ?? {}, configDir, opts.kitRoot ?? kitRoot())
+
   const out = {
     $schema: "https://opencode.ai/config.json",
     ...base_,
@@ -480,11 +599,20 @@ export function generateConfig(p, opts = {}) {
     // numbers if this ever needs arguing again.
     tool_output: { max_lines: 2000, max_bytes: 51200 },
 
-    skills: base.skills ?? {},
+    // The skills paths: only the entries that resolve where they would be
+    // read from. A dead one is dropped from the file and named in the
+    // header - a path to nothing is noise every reader pays for.
+    skills: skillPaths.skills ?? {},
 
     experimental: {
       batch_tool: true,
-      continue_loop_on_deny: true,
+      // A denial is a stop, not a prompt. With this on, opencode hands the
+      // guard's refusal back to the model and continues the same loop; the
+      // measured session made 138 requests and 7,559,016 context tokens in 29
+      // minutes on six `shared token window` denials, each retry carrying
+      // the whole prompt. Off, the denial ends the turn and the error is what
+      // the user sees.
+      continue_loop_on_deny: false,
       ...(base.experimental ?? {}),
     },
 
@@ -532,6 +660,10 @@ export function generateConfig(p, opts = {}) {
     instructionsPath,
     unhealthy,
     dropped: own.dropped,
+    removedLanes,
+    removedBundled,
+    skillsDropped: skillPaths.dropped,
+    skills: opts.skills,
   })
 }
 
@@ -539,7 +671,8 @@ export function generateConfig(p, opts = {}) {
  * @param {Record<string, any>} cfg
  * @param {Profile} p
  * @param {{ comments: boolean, instructionsPath?: string, unhealthy?: Set<string>,
- *          dropped?: string[] }} opts
+ *          dropped?: string[], removedLanes?: string[], removedBundled?: string[],
+ *          skillsDropped?: string[], skills?: boolean }} opts
  * @returns {string}
  */
 function render(cfg, p, opts) {
@@ -589,6 +722,12 @@ function render(cfg, p, opts) {
     `${c}output cap   ${p.limits.output.toLocaleString("en-US")} tokens`,
     `${c}reasoning    ${levels.length ? levels.join(" < ") : "(not tunable)"}`,
     `${c}retention    ${effective.retention}${effective.retention === "may-train" ? "  <-- prompts may train a model" : ""}`,
+    ...(opts.skills === false
+      ? [
+          `${c}skills       off (--no-skills): the skill list is not in the prompt`,
+          `${c}             (every skill's name and description, on every request)`,
+        ]
+      : []),
     ...(effective.retention !== p.retention
       ? [
           `${c}             base ${p.provider}/${p.model} is ${p.retention}, but ${effective.worst} makes the whole file ${effective.retention}`,
@@ -612,6 +751,33 @@ function render(cfg, p, opts) {
           ...opts.dropped.map((d) => `${c}  ${d}`),
         ]
       : []),
+    ...(opts.removedLanes?.length
+      ? [
+          `${c}`,
+          `${c}Lanes this profile does not manage, removed from the agent map:`,
+          ...opts.removedLanes.map((r) => `${c}  ${r}`),
+          `${c}A lane whose prompt you had rewritten is left alone instead - pin the`,
+          `${c}lane back with a prompt of your own if it was yours.`,
+        ]
+      : []),
+    ...(opts.removedBundled?.length
+      ? [
+          `${c}`,
+          `${c}Bundled subagents removed from the agent map (prompt prompts/agents/*):`,
+          ...opts.removedBundled.map((r) => `${c}  ${r}`),
+          `${c}Their descriptions were loaded on every request; hand-written agents`,
+          `${c}are left alone.`,
+        ]
+      : []),
+    ...(opts.skillsDropped?.length
+      ? [
+          `${c}`,
+          `${c}Skills paths that do not resolve, dropped from skills.paths:`,
+          ...opts.skillsDropped.map((s) => `${c}  ${s}`),
+          `${c}A path to nothing is noise every reader pays for; the kit's own`,
+          `${c}skills arrive as per-file links in the default skills directory.`,
+        ]
+      : []),
     `${c}`,
     `${c}Derived numbers, do not hand-edit:`,
     `${c}  compaction.reserved  ${reservedTokens(p, { unhealthy }).toLocaleString("en-US")}  (${Math.round((p.effort?.reserveShare ?? 0.12) * 100)}% of the narrowest input cap in play, held back for reasoning growth)`,