@saasontools/strauss-kb 0.1.22 → 0.1.23

package/dist/{chunk-AEO5U42S.js → chunk-XENLCPL5.js}

@@ -3044,27 +3044,273 @@ var anchorSetCommandInput = z7.object({
   offline: z7.boolean().optional().describe("With resolve, read foreign anchors from the repo cache only.")
 });
 
-// src/commands/anchor-resolve.ts
+// src/commands/anchor-resolve/command.ts
+import { z as z9 } from "zod";
+
+// src/commands/anchor-resolve/apply.ts
 import { z as z8 } from "zod";
+async function baseFrozen(cwd, bundlePath2) {
+  try {
+    await assertBaseNotFrozen(cwd, bundlePath2);
+    return false;
+  } catch (caught) {
+    if (!(caught instanceof KbBaseFrozenError)) throw caught;
+    return true;
+  }
+}
+async function applyPlan(plans, target) {
+  if (!plans.some((plan) => plan.write)) {
+    return { results: plans.map((plan) => plan.finding) };
+  }
+  let failure = target.frozen ? "frozen" : void 0;
+  let error;
+  if (!failure) {
+    try {
+      await target.store.updateAnchors(
+        target.bundlePath,
+        target.conceptId,
+        plans.map((plan) => plan.anchor),
+        target.actor
+      );
+    } catch (caught) {
+      if (caught instanceof BaseError || caught instanceof z8.ZodError) {
+        throw caught;
+      }
+      failure = "write-failed";
+      error = clamp(caught instanceof Error ? caught.message : String(caught));
+    }
+  }
+  return {
+    results: plans.map((plan) => settle(plan, failure)),
+    ...error ? { error } : {}
+  };
+}
+function settle(plan, failure) {
+  if (!plan.write) return plan.finding;
+  if (failure) {
+    return { ...plan.finding, outcome: "failed", outcomeReason: failure };
+  }
+  if (plan.write === "refresh") return plan.finding;
+  return plan.write === "stamp" ? { ...plan.finding, state: "stamped", outcome: "applied" } : { ...plan.finding, outcome: "applied", rebaselined: true };
+}
+function clamp(message) {
+  const line = message.split("\n")[0] ?? "";
+  return line.length > 200 ? `${line.slice(0, 199)}\u2026` : line;
+}
+
+// src/commands/anchor-resolve/sources.ts
+async function readSources(anchors, root, offline) {
+  const origin = new LazyOrigin(root);
+  if (anchors.some((anchor) => anchor.repo)) await origin.prime();
+  const foreign = new Map(
+    anchors.map((anchor) => [anchor, origin.isForeign(anchor)])
+  );
+  const local = anchors.filter(
+    (anchor) => !foreign.get(anchor) && anchor.side !== "old"
+  );
+  const committed = anchors.filter(
+    (anchor) => !foreign.get(anchor) && anchor.side === "old"
+  );
+  const remote = anchors.filter((anchor) => foreign.get(anchor));
+  const reads = await readAnchorFiles(
+    local.map((anchor) => anchor.file),
+    anchorFileReader(root)
+  );
+  const atRef = await readCommitted(root, committed);
+  const blobs = await readRemoteAnchors(remote.flatMap(remoteWants), {
+    offline
+  });
+  const sources = /* @__PURE__ */ new Map();
+  for (const anchor of local) {
+    const read = reads.get(anchor.file);
+    sources.set(
+      anchor,
+      read.ok ? { ok: true, source: read.source } : { ok: false, reason: read.reason }
+    );
+  }
+  for (const anchor of committed) {
+    const read = atRef.get(atRefKey(anchor));
+    sources.set(
+      anchor,
+      read.ok ? { ok: true, source: read.source } : { ok: false, reason: read.reason }
+    );
+  }
+  for (const anchor of remote) {
+    const repo = anchor.repo;
+    const key2 = normalizeRepoUrl(repo);
+    const atDefault = blobs.get(wantKey(key2, void 0, anchor.file));
+    const primary = anchor.ref ? blobs.get(wantKey(key2, anchor.ref, anchor.file)) : atDefault;
+    if (!primary?.ok) {
+      sources.set(anchor, {
+        ok: false,
+        reason: primary?.ok === false ? primary.reason : "remote-unreachable",
+        repo
+      });
+      continue;
+    }
+    sources.set(anchor, {
+      ok: true,
+      source: primary.source,
+      repo,
+      ...anchor.ref && atDefault?.ok ? { head: atDefault.source } : {}
+    });
+  }
+  return sources;
+}
+
+// src/commands/anchor-resolve/plan.ts
+async function planAnchors(anchors, options) {
+  const { root, offline, rebaseline, restamp, check, frozen, now } = options;
+  const sources = await readSources(anchors, root, offline);
+  const resolvers = defaultAnchorResolvers({ offline });
+  await prepareResolvers(
+    resolvers,
+    anchors.map((anchor) => anchor.file)
+  );
+  const plans = [];
+  for (const anchor of anchors) {
+    const base2 = {
+      file: anchor.file,
+      ...anchor.symbol ? { symbol: anchor.symbol } : {},
+      ...anchor.side === "old" ? { side: "old" } : {},
+      // Carried onto unresolved findings too: an anchor that once hashed
+      // and now resolves to nothing is a broken anchor, and the exit code
+      // has to be able to tell it from one nobody ever stamped.
+      ...anchor.hash ? { storedHash: anchor.hash } : {}
+    };
+    const source = sources.get(anchor);
+    if (source.repo) base2.repo = source.repo;
+    if (!source.ok) {
+      plans.push({
+        finding: { ...base2, state: "unresolved", reason: source.reason },
+        anchor
+      });
+      continue;
+    }
+    const outcome = resolveAnchorSpan(source.source, anchor, resolvers);
+    if (!outcome.ok) {
+      plans.push({
+        finding: { ...base2, state: "unresolved", reason: outcome.reason },
+        anchor
+      });
+      continue;
+    }
+    const resolved = outcome.span;
+    const producedBy = outcome.resolver;
+    const { hash: currentHash, kind } = anchorHashOf(anchor, outcome);
+    const currentLines = resolved.endLine - resolved.startLine + 1;
+    const stampedKind = outcome.normalized ? "ast" : "raw";
+    const stampedHash = outcome.normalized ? anchorHashOf({ ...anchor, hash: void 0 }, outcome).hash : currentHash;
+    const stamped = {
+      ...anchor,
+      hash: stampedHash,
+      hash_kind: stampedKind,
+      lines: currentLines,
+      resolved_at: now(),
+      ...producedBy ? { resolver: producedBy } : {}
+    };
+    const pinned = anchor.ref !== void 0 && source.repo !== void 0;
+    if (!anchor.hash) {
+      plans.push({
+        finding: {
+          ...base2,
+          state: "unstamped",
+          currentHash: stampedHash,
+          hashKind: stampedKind,
+          ...producedBy ? { resolver: producedBy } : {}
+        },
+        anchor: check ? anchor : stamped,
+        ...check ? {} : { write: "stamp" }
+      });
+      continue;
+    }
+    if (anchor.hash !== currentHash) {
+      plans.push({
+        finding: {
+          ...base2,
+          state: "drifted",
+          currentHash,
+          hashKind: kind,
+          diffSize: lineDelta(anchor, currentLines),
+          ...producedBy ? { resolver: producedBy } : {},
+          // A regex-stamped anchor re-read by tree-sitter drifts because the
+          // resolver changed, not because the code did.
+          ...resolverChanged(source.source, anchor, producedBy) ? { reason: "resolver-changed" } : {},
+          ...pinned ? { remoteState: "drifted-from-ref" } : {}
+        },
+        anchor: rebaseline && !check ? stamped : anchor,
+        ...rebaseline && !check ? { write: "rebaseline" } : {}
+      });
+      continue;
+    }
+    const onDefault = pinned ? headHash(source, anchor, resolvers) : void 0;
+    if (onDefault && onDefault.hash !== anchor.hash) {
+      plans.push({
+        finding: {
+          ...base2,
+          state: "drifted",
+          currentHash: onDefault.hash,
+          diffSize: lineDelta(anchor, onDefault.lines),
+          remoteState: "drifted-on-default",
+          ...rebaseline ? {
+            outcome: "skipped",
+            outcomeReason: "pinned-ref"
+          } : {}
+        },
+        anchor
+      });
+      continue;
+    }
+    const backfill = anchor.resolved_at === void 0 && !frozen;
+    const refresh = !check && (restamp || backfill);
+    plans.push({
+      finding: {
+        ...base2,
+        state: "match",
+        currentHash,
+        hashKind: kind,
+        ...producedBy ? { resolver: producedBy } : {},
+        ...pinned ? { remoteState: "matches-ref" } : {}
+      },
+      anchor: refresh ? { ...anchor, resolved_at: now() } : anchor,
+      ...refresh ? { write: "refresh" } : {}
+    });
+  }
+  return plans;
+}
+function lineDelta(anchor, current) {
+  return anchor.lines === void 0 ? null : Math.abs(current - anchor.lines);
+}
+function headHash(source, anchor, resolvers) {
+  if (source.head === void 0) return void 0;
+  const outcome = resolveAnchorSpan(source.head, anchor, resolvers);
+  if (!outcome.ok) return void 0;
+  return {
+    hash: hashAnchorText(outcome.span.text),
+    lines: outcome.span.endLine - outcome.span.startLine + 1
+  };
+}
+
+// src/commands/anchor-resolve/command.ts
 var anchorResolveCommand = define({
   name: "anchor-resolve",
   tool: "kb_anchor_resolve",
   usage: "anchor-resolve <concept-id> [--repo-root <path>] [--offline] [--rebaseline] [--restamp] [--check]",
-  description: "Resolve a record's anchors: stamp a hash onto anchors that lack one, report drift where the code moved. An anchor naming another repository is read from that remote through a bare cache; --offline uses the cache only. Never writes verified[]; a judgment is kb_verify. Exits non-zero on drift.",
-  input: z8.object({
+  description: "Resolve a record's anchors: stamp a hash onto anchors that lack one, report drift where the code moved. An anchor naming another repository is read from that remote through a bare cache; --offline uses the cache only. Never writes verified[]; a judgment is kb_verify. Each result says what it compared and whether the write applied.",
+  input: z9.object({
     bundlePath,
     conceptId,
-    repoRoot: z8.string().min(1).optional(),
-    offline: z8.boolean().optional().describe(
+    repoRoot: z9.string().min(1).optional(),
+    offline: z9.boolean().optional().describe(
       "Resolve foreign anchors from the local repo cache only, never fetching."
     ),
-    rebaseline: z8.boolean().optional().describe(
+    rebaseline: z9.boolean().optional().describe(
       "Accept the current code as the new baseline for anchors that drifted."
     ),
-    restamp: z8.boolean().optional().describe(
+    restamp: z9.boolean().optional().describe(
       "Refresh `resolved_at` on anchors that already match. Off by default, so a green run writes nothing."
     ),
-    check: z8.boolean().optional().describe(
+    check: z9.boolean().optional().describe(
       "Resolve and report only: no hash, no `resolved_at`, no log entry."
     )
   }),
@@ -3103,221 +3349,62 @@ var anchorResolveCommand = define({
         note: "record has no anchors"
       };
     }
-    const results = [];
-    const updated = [];
-    let dirty = false;
-    const sources = await readSources(anchors, root, offline === true);
-    const resolvers = defaultAnchorResolvers({ offline: offline === true });
-    await prepareResolvers(
-      resolvers,
-      anchors.map((anchor) => anchor.file)
-    );
-    for (const anchor of anchors) {
-      const base2 = {
-        file: anchor.file,
-        ...anchor.symbol ? { symbol: anchor.symbol } : {},
-        ...anchor.side === "old" ? { side: "old" } : {},
-        // Carried onto unresolved findings too: an anchor that once hashed
-        // and now resolves to nothing is a broken anchor, and the exit code
-        // has to be able to tell it from one nobody ever stamped.
-        ...anchor.hash ? { storedHash: anchor.hash } : {}
-      };
-      const source = sources.get(anchor);
-      if (source.repo) base2.repo = source.repo;
-      if (!source.ok) {
-        results.push({ ...base2, state: "unresolved", reason: source.reason });
-        updated.push(anchor);
-        continue;
-      }
-      const outcome = resolveAnchorSpan(source.source, anchor, resolvers);
-      if (!outcome.ok) {
-        results.push({
-          ...base2,
-          state: "unresolved",
-          reason: outcome.reason
-        });
-        updated.push(anchor);
-        continue;
-      }
-      const resolved = outcome.span;
-      const producedBy = outcome.resolver;
-      const { hash: currentHash, kind } = anchorHashOf(anchor, outcome);
-      const currentLines = resolved.endLine - resolved.startLine + 1;
-      const stampedKind = outcome.normalized ? "ast" : "raw";
-      const stampedHash = outcome.normalized ? anchorHashOf({ ...anchor, hash: void 0 }, outcome).hash : currentHash;
-      const stamped = {
-        ...anchor,
-        hash: stampedHash,
-        hash_kind: stampedKind,
-        lines: currentLines,
-        resolved_at: now(),
-        ...producedBy ? { resolver: producedBy } : {}
-      };
-      const pinned = anchor.ref !== void 0 && source.repo !== void 0;
-      if (!anchor.hash) {
-        results.push({
-          ...base2,
-          state: check ? "unstamped" : "stamped",
-          currentHash: stampedHash,
-          hashKind: stampedKind,
-          ...producedBy ? { resolver: producedBy } : {}
-        });
-        updated.push(stamped);
-        dirty = true;
-        continue;
-      }
-      if (anchor.hash !== currentHash) {
-        results.push({
-          ...base2,
-          state: "drifted",
-          currentHash,
-          hashKind: kind,
-          diffSize: lineDelta(anchor, currentLines),
-          ...producedBy ? { resolver: producedBy } : {},
-          // A regex-stamped anchor re-read by tree-sitter drifts because the
-          // resolver changed, not because the code did.
-          ...resolverChanged(source.source, anchor, producedBy) ? { reason: "resolver-changed" } : {},
-          ...pinned ? { remoteState: "drifted-from-ref" } : {},
-          ...rebaseline ? { rebaselined: true } : {}
-        });
-        updated.push(rebaseline ? stamped : anchor);
-        if (rebaseline) dirty = true;
-        continue;
-      }
-      const onDefault = pinned ? headHash(source, anchor, resolvers) : void 0;
-      if (onDefault && onDefault.hash !== anchor.hash) {
-        results.push({
-          ...base2,
-          state: "drifted",
-          currentHash: onDefault.hash,
-          diffSize: lineDelta(anchor, onDefault.lines),
-          remoteState: "drifted-on-default"
-        });
-        updated.push(anchor);
-        continue;
-      }
-      results.push({
-        ...base2,
-        state: "match",
-        currentHash,
-        hashKind: kind,
-        ...producedBy ? { resolver: producedBy } : {},
-        ...pinned ? { remoteState: "matches-ref" } : {}
-      });
-      const refresh = restamp || anchor.resolved_at === void 0;
-      updated.push(refresh ? { ...anchor, resolved_at: now() } : anchor);
-      if (refresh) dirty = true;
-    }
-    let frozen = false;
-    if (dirty && !check) {
-      try {
-        await assertBaseNotFrozen(process.cwd(), path);
-      } catch (error) {
-        if (!(error instanceof KbBaseFrozenError)) throw error;
-        frozen = true;
-      }
-      if (!frozen) await store.updateAnchors(path, id, updated, actor);
-    }
-    const frozenNote = frozen ? { frozen: true, note: "base is frozen: nothing was stamped" } : {};
+    const frozen = check ? false : await baseFrozen(process.cwd(), path);
+    const plans = await planAnchors(anchors, {
+      root,
+      offline: offline === true,
+      rebaseline: rebaseline === true,
+      restamp: restamp === true,
+      check: check === true,
+      frozen,
+      now
+    });
+    const applied = await applyPlan(plans, {
+      store,
+      actor,
+      bundlePath: path,
+      conceptId: id,
+      frozen
+    });
+    const results = applied.results;
+    const refused = frozen && plans.some((plan) => plan.write);
     const hints = grammarHints();
     const hintNote = hints.length ? { hints } : {};
     const unreachable = results.filter(
       (entry) => isUncheckedReason(entry.reason)
     ).length;
     const matches3 = results.filter((entry) => entry.state === "match").length;
-    const note = `${matches3}/${results.length - unreachable} anchors match, ${unreachable} unreachable`;
+    const note = [
+      unreachable ? `${matches3}/${results.length - unreachable} anchors match, ${unreachable} unreachable` : "",
+      refused ? "base is frozen: nothing was stamped" : "",
+      applied.error ? `nothing was written: ${applied.error}` : ""
+    ].filter(Boolean).join("; ");
     return {
       conceptId: id,
       results,
-      ...unreachable ? { note } : {},
-      ...frozenNote,
+      ...note ? { note } : {},
+      ...refused ? { frozen: true } : {},
       ...hintNote
     };
   },
+  // Drift is a finding until a write settles it: a rebaseline the base took is
+  // the answer to the drift it reports, while one refused, skipped, or never
+  // asked for leaves the gate exactly what it was meant to catch.
+  //
   // A stored hash that no longer resolves is a broken anchor, not an absence:
-  // the file was deleted or the symbol renamed, and exiting zero on it would
-  // let the one edit that destroys an anchor pass the gate that exists to
-  // catch it. An anchor nobody ever stamped is still just unstamped, and one
-  // whose remote nothing could reach was never checked — failing CI on either
-  // would gate on work this command did not do.
+  // the file was deleted or the symbol renamed. An anchor nobody ever stamped
+  // is still just unstamped, and one whose remote nothing could reach was
+  // never checked — failing CI on either would gate on work this command did
+  // not do.
   failsWhen: (result) => result.results.some(
-    (entry) => entry.state === "drifted" || entry.state === "unresolved" && entry.storedHash !== void 0 && !isUncheckedReason(entry.reason)
+    (entry) => entry.outcome === "failed" || entry.outcome === "skipped" || entry.state === "drifted" && entry.outcome !== "applied" || entry.state === "unresolved" && entry.storedHash !== void 0 && !isUncheckedReason(entry.reason)
   )
 });
-function lineDelta(anchor, current) {
-  return anchor.lines === void 0 ? null : Math.abs(current - anchor.lines);
-}
-function headHash(source, anchor, resolvers) {
-  if (source.head === void 0) return void 0;
-  const outcome = resolveAnchorSpan(source.head, anchor, resolvers);
-  if (!outcome.ok) return void 0;
-  return {
-    hash: hashAnchorText(outcome.span.text),
-    lines: outcome.span.endLine - outcome.span.startLine + 1
-  };
-}
-async function readSources(anchors, root, offline) {
-  const origin = new LazyOrigin(root);
-  if (anchors.some((anchor) => anchor.repo)) await origin.prime();
-  const foreign = new Map(
-    anchors.map((anchor) => [anchor, origin.isForeign(anchor)])
-  );
-  const local = anchors.filter(
-    (anchor) => !foreign.get(anchor) && anchor.side !== "old"
-  );
-  const committed = anchors.filter(
-    (anchor) => !foreign.get(anchor) && anchor.side === "old"
-  );
-  const remote = anchors.filter((anchor) => foreign.get(anchor));
-  const reads = await readAnchorFiles(
-    local.map((anchor) => anchor.file),
-    anchorFileReader(root)
-  );
-  const atRef = await readCommitted(root, committed);
-  const blobs = await readRemoteAnchors(remote.flatMap(remoteWants), {
-    offline
-  });
-  const sources = /* @__PURE__ */ new Map();
-  for (const anchor of local) {
-    const read = reads.get(anchor.file);
-    sources.set(
-      anchor,
-      read.ok ? { ok: true, source: read.source } : { ok: false, reason: read.reason }
-    );
-  }
-  for (const anchor of committed) {
-    const read = atRef.get(atRefKey(anchor));
-    sources.set(
-      anchor,
-      read.ok ? { ok: true, source: read.source } : { ok: false, reason: read.reason }
-    );
-  }
-  for (const anchor of remote) {
-    const repo = anchor.repo;
-    const key2 = normalizeRepoUrl(repo);
-    const atDefault = blobs.get(wantKey(key2, void 0, anchor.file));
-    const primary = anchor.ref ? blobs.get(wantKey(key2, anchor.ref, anchor.file)) : atDefault;
-    if (!primary?.ok) {
-      sources.set(anchor, {
-        ok: false,
-        reason: primary?.ok === false ? primary.reason : "remote-unreachable",
-        repo
-      });
-      continue;
-    }
-    sources.set(anchor, {
-      ok: true,
-      source: primary.source,
-      repo,
-      ...anchor.ref && atDefault?.ok ? { head: atDefault.source } : {}
-    });
-  }
-  return sources;
-}
 
 // src/commands/anchor-set/command.ts
 var NOTE = "pointers only: nothing was resolved or verified. Run anchor-resolve to check the new pointers, --rebaseline to accept the code, or pass resolve to do both here.";
 var STAMPED_NOTE = "pointers set and stamped against the current code. Not verification: run verify separately if someone reviewed it.";
+var INCOMPLETE_NOTE = "pointers set, but not every anchor was stamped: see each resolved entry's state and outcome.";
 var anchorSetCommand = define({
   name: "anchor-set",
   tool: "kb_anchor_set",
@@ -3374,23 +3461,29 @@ var anchorSetCommand = define({
       })
     );
     const after = await store.read(path, id);
+    const stamped = resolved.results.every(
+      (entry) => entry.state === "match" || entry.outcome === "applied"
+    );
     return {
       conceptId: id,
       reason: input.reason,
       changes,
       anchors: after?.frontmatter.strauss_anchors ?? [],
-      baseline: "stamped",
+      baseline: stamped ? "stamped" : "incomplete",
       resolved: resolved.results,
-      note: STAMPED_NOTE
+      note: stamped ? STAMPED_NOTE : INCOMPLETE_NOTE
     };
   },
   // With `resolve`, a pointer that names nothing is a failed set, not a
-  // finding to read later. A remote nothing could reach was never checked, so
-  // it does not fail — the same line anchor-resolve draws.
-  failsWhen: (result) => (result.resolved ?? []).some((entry) => {
-    const { state, reason } = entry;
-    return state === "unresolved" && !isUncheckedReason(reason);
-  })
+  // finding to read later, and a stamp that did not land fails as it does in
+  // anchor-resolve. A remote nothing could reach was never checked, so it does
+  // not fail — the same line anchor-resolve draws.
+  failsWhen: (result, input) => {
+    const resolved = result.resolved ?? [];
+    return resolved.some(
+      (entry) => entry.state === "unresolved" && !isUncheckedReason(entry.reason)
+    ) || anchorResolveCommand.failsWhen?.({ results: resolved }, input) === true;
+  }
 });
 
 // src/adjudicate.ts
@@ -5227,16 +5320,16 @@ function recordType(conceptId2) {
 }
 
 // src/commands/promote/model.ts
-import { z as z9 } from "zod";
-var promoteInputSchema = z9.object({
+import { z as z10 } from "zod";
+var promoteInputSchema = z10.object({
   bundlePath,
-  conceptIds: z9.array(conceptId).max(64).optional().describe("Records to copy into the target base. Omit with `list`."),
-  to: z9.string().min(1).optional().describe("Absolute path to the base being promoted into."),
-  source: z9.string().min(1).optional().describe(
+  conceptIds: z10.array(conceptId).max(64).optional().describe("Records to copy into the target base. Omit with `list`."),
+  to: z10.string().min(1).optional().describe("Absolute path to the base being promoted into."),
+  source: z10.string().min(1).optional().describe(
     "Where the promotion came from, usually the pull request URL. Recorded on each copy as a source."
   ),
-  force: z9.boolean().optional().describe("Overwrite a record the target base already holds."),
-  list: z9.boolean().optional().describe("List the source base's candidates instead of promoting.")
+  force: z10.boolean().optional().describe("Overwrite a record the target base already holds."),
+  list: z10.boolean().optional().describe("List the source base's candidates instead of promoting.")
 }).refine((input) => input.list === true || input.to !== void 0, {
   message: "promote needs a target base \u2014 pass --to <bundle>, or --list",
   path: ["to"]
@@ -5374,14 +5467,14 @@ function renderPromote(result) {
 }
 
 // src/kb-log.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var LOG_FILE = "log.jsonl";
-var kbLogAnchorChangeSchema = z10.object({
-  op: z10.enum(["move", "add", "drop"]),
+var kbLogAnchorChangeSchema = z11.object({
+  op: z11.enum(["move", "add", "drop"]),
   from: kbAnchorLocatorSchema.optional(),
   to: kbAnchorLocatorSchema.optional()
 }).strict();
-var kbLogEntryFields = z10.object({
+var kbLogEntryFields = z11.object({
   // Validated, not just `min(1)`: `at` is a sort key (see `parseLog`
   // below), and a value that isn't actually chronological — a Unix
   // timestamp, a human-typed date, garbage — would sort wrong without
@@ -5390,23 +5483,23 @@ var kbLogEntryFields = z10.object({
   // and rejects everything else, including a non-`Z` offset — so a
   // malformed `at` is reported the same way a malformed line already is,
   // rather than silently sorting into the wrong place.
-  at: z10.iso.datetime(),
-  by: z10.string().min(1),
-  operation: z10.string().min(1),
-  conceptId: z10.string().min(1),
+  at: z11.iso.datetime(),
+  by: z11.string().min(1),
+  operation: z11.string().min(1),
+  conceptId: z11.string().min(1),
   /**
    * The operation's other end, where it has one: a second concept id for
    * supersession, the other base's path for promotion.
    */
-  target: z10.string().min(1).optional(),
+  target: z11.string().min(1).optional(),
   /**
    * Why the operation was performed, where the operation demands one.
    * `anchor-set` does: a pointer moved by a reader is only auditable if
    * the reading is recorded beside it.
    */
-  reason: z10.string().min(1).optional(),
+  reason: z11.string().min(1).optional(),
   /** What `anchor-set` changed, derived from the record before and after. */
-  anchors: z10.array(kbLogAnchorChangeSchema).optional()
+  anchors: z11.array(kbLogAnchorChangeSchema).optional()
 });
 var kbLogEntrySchema = kbLogEntryFields.passthrough();
 var kbLogEntryWriteSchema = kbLogEntryFields.strict();
@@ -5450,14 +5543,14 @@ function parseLog(raw) {
 }
 
 // src/json-schema.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 function kbJsonSchemas() {
   return {
-    recordFrontmatter: z11.toJSONSchema(kbRecordFrontmatterSchema, {
+    recordFrontmatter: z12.toJSONSchema(kbRecordFrontmatterSchema, {
       io: "input"
     }),
-    composeInput: z11.toJSONSchema(composeInputSchema, { io: "input" }),
-    logEntry: z11.toJSONSchema(kbLogEntrySchema, { io: "input" })
+    composeInput: z12.toJSONSchema(composeInputSchema, { io: "input" }),
+    logEntry: z12.toJSONSchema(kbLogEntrySchema, { io: "input" })
   };
 }
 
@@ -5510,13 +5603,13 @@ function byGeneratedAt(left, right) {
 }
 
 // src/commands/answer.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 var answerCommand = define({
   name: "answer",
   tool: "kb_answer",
   usage: "answer <concept-id> <answer...>",
   description: "Resolve an open question: set status, stamp who and when, append an Answer section. If the answer overturns a decision or assumption, supersede that record explicitly.",
-  input: z12.object({ bundlePath, conceptId, answer: z12.string().min(1) }),
+  input: z13.object({ bundlePath, conceptId, answer: z13.string().min(1) }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
     conceptId: argv[1],
@@ -5530,27 +5623,27 @@ var answerCommand = define({
 });
 
 // src/commands/backlinks.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 var backlinksCommand = define({
   name: "backlinks",
   tool: "kb_backlinks",
   usage: "backlinks <concept-id>",
   description: "Who points at this record: every inbound typed causal link (`strauss_links`), one hop, every rel including `related_to`, each with its rel and the standing of the record that made it. Use it when you need the exact edges \u2014 reviewing or renaming a record.",
-  input: z13.object({ bundlePath, conceptId }),
+  input: z14.object({ bundlePath, conceptId }),
   fromArgv: (argv, path) => ({ bundlePath: path, conceptId: argv[1] }),
   run: async ({ store }, { bundlePath: path, conceptId: id }) => store.backlinks(path, id)
 });
 
 // src/commands/catalog.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 var catalogCommand = define({
   name: "catalog",
   tool: "kb_catalog",
   usage: "catalog [type] [--tag T]...",
   description: "Lists every record as one line \u2014 concept id, type, title, standing, and a stale flag \u2014 at roughly thirty tokens each. Pick this over kb_load once kb_load refuses: kb_catalog never refuses. Superseded records show only their replacement; fetch bodies with kb_load, kb_pack, kb_query, or kb_trace.",
-  input: z14.object({
+  input: z15.object({
     bundlePath,
-    type: z14.enum(KB_RECORD_TYPES).optional(),
+    type: z15.enum(KB_RECORD_TYPES).optional(),
     tags: TAGS
   }),
   fromArgv: (argv, path) => {
@@ -5622,10 +5715,10 @@ function count(value, noun) {
 import { Buffer } from "buffer";
 import { open } from "fs/promises";
 import { join as join6 } from "path";
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 
 // src/commands/match/command.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 
 // src/commands/match/errors.ts
 var KbMatchInputError = class extends BaseError {
@@ -5645,21 +5738,21 @@ var KbMatchInputError = class extends BaseError {
 };
 
 // src/commands/match/model.ts
-import { z as z15 } from "zod";
-var diffHunkSchema = z15.object({
-  startLine: z15.number().int().positive(),
-  endLine: z15.number().int().positive(),
-  side: z15.enum(["old", "new"]).optional()
+import { z as z16 } from "zod";
+var diffHunkSchema = z16.object({
+  startLine: z16.number().int().positive(),
+  endLine: z16.number().int().positive(),
+  side: z16.enum(["old", "new"]).optional()
 }).passthrough();
-var diffFileSchema = z15.object({
-  filePath: z15.string().min(1).describe("Repo-relative, spelled the way anchors are."),
-  hunks: z15.array(diffHunkSchema)
+var diffFileSchema = z16.object({
+  filePath: z16.string().min(1).describe("Repo-relative, spelled the way anchors are."),
+  hunks: z16.array(diffHunkSchema)
 });
-var symbolRangeSchema = z15.object({
-  file: z15.string().min(1),
-  symbol: z15.string().min(1),
-  startLine: z15.number().int().positive(),
-  endLine: z15.number().int().positive()
+var symbolRangeSchema = z16.object({
+  file: z16.string().min(1),
+  symbol: z16.string().min(1),
+  startLine: z16.number().int().positive(),
+  endLine: z16.number().int().positive()
 });
 
 // src/commands/match/parse-unified-diff.ts
@@ -5908,17 +6001,17 @@ var matchCommand = define({
   tool: "kb_match",
   usage: "match --git <base>..<head> | --stdin [--repo-root <path>] [--offline] [--include-non-current]",
   description: "Which records sit on each changed hunk: the anchored records per file range, current first, each with its standing and the anchor that matched. kb_load hands over a whole base; this narrows a diff. Symbol ranges resolve from repoRoot when omitted; non-current records need includeNonCurrent.",
-  input: z16.object({
+  input: z17.object({
     bundlePath,
-    files: z16.array(diffFileSchema).describe("The changed files, each with its post-change line ranges."),
-    symbolRanges: z16.array(symbolRangeSchema).optional().describe(
+    files: z17.array(diffFileSchema).describe("The changed files, each with its post-change line ranges."),
+    symbolRanges: z17.array(symbolRangeSchema).optional().describe(
       "Symbol spans the caller already has. Resolved from repoRoot when omitted."
     ),
     repoRoot: REPO_ROOT,
-    offline: z16.boolean().optional().describe(
+    offline: z17.boolean().optional().describe(
       "Resolve symbol ranges from what is already on disk, never fetching a grammar."
     ),
-    includeNonCurrent: z16.boolean().optional().describe(
+    includeNonCurrent: z17.boolean().optional().describe(
       "Return superseded, rejected and unsettled records too, each carrying its standing."
     )
   }),
@@ -6022,22 +6115,22 @@ function project(match, ranges, all) {
 
 // src/commands/classify.ts
 var classifyFileSchema = diffFileSchema.extend({
-  hunks: z17.array(
-    diffHunkSchema.extend({ lines: z17.array(z17.string()).optional() })
+  hunks: z18.array(
+    diffHunkSchema.extend({ lines: z18.array(z18.string()).optional() })
   ),
-  renamedFrom: z17.string().min(1).optional().describe("Where `git diff -M` says the path came from."),
-  similarity: z17.number().min(0).max(100).optional()
+  renamedFrom: z18.string().min(1).optional().describe("Where `git diff -M` says the path came from."),
+  similarity: z18.number().min(0).max(100).optional()
 });
 var classifyCommand = define({
   name: "classify",
   tool: "kb_classify",
   usage: "classify --git <base>..<head> | --stdin [--repo-root <path>] [--offline]",
   description: "What kind of change each file carries: test, config, ci, docs, lockfile, generated, boilerplate, rename or source, with the rule that decided it. Derived from the diff and never stored; a `review:generated`, `review:boilerplate` or `review:move` fact anchored on a file overrides the heuristic. kb_match says what sits on a hunk; this says whether to read it.",
-  input: z17.object({
+  input: z18.object({
     bundlePath,
-    files: z17.array(classifyFileSchema).describe("The changed files, each with its line ranges."),
+    files: z18.array(classifyFileSchema).describe("The changed files, each with its line ranges."),
     repoRoot: REPO_ROOT,
-    offline: z17.boolean().optional().describe(
+    offline: z18.boolean().optional().describe(
       "Resolve symbol ranges from what is already on disk, never fetching a grammar."
     )
   }),
@@ -6148,29 +6241,29 @@ function renderClassify(result) {
 }
 
 // src/commands/context.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 var contextCommand = define({
   name: "context",
   tool: "kb_context",
   usage: "context [--profile NAME] [--budget N] [--full-under N] [--exclude-tag T]... [--format json] [--event NAME]",
   description: "Index block of pinned bases (ids, titles, standing) for injection at context birth. Takes no bundlePath \u2014 reads the workspace pin manifests. Empty when nothing is pinned; refuses over budget rather than truncating. Budget precedence: flags, then the manifest `context[profile]` over `context.default`, then the built-in profile, then package defaults.",
-  input: z18.object({
-    budgetTokens: z18.number().int().positive().optional().describe(
+  input: z19.object({
+    budgetTokens: z19.number().int().positive().optional().describe(
       "Ceiling on the whole emitted block; past it the command refuses with a list of bases rather than truncating. Defaults to 4000."
     ),
-    fullUnderTokens: z18.number().int().positive().optional().describe(
+    fullUnderTokens: z19.number().int().positive().optional().describe(
       "Per-base rendering threshold, applied before the budget: a base whose complete load fits under this arrives as full records instead of index lines, and the whole block still answers to budgetTokens. Off by default \u2014 index-only is the safe default at a context birth, because injected bodies outlive the qualifiers on them; the session-start profile opts tiny bases in at 1500."
     ),
-    profile: z18.string().optional().describe(
+    profile: z19.string().optional().describe(
       "Named budget set: built-ins are session-start (full-under 1500), compact and turn (budget 2500); the manifests' `context` tables override per repo. Unknown names fall through to defaults rather than failing."
     ),
-    excludeTags: z18.array(z18.string().min(1)).optional().describe(
+    excludeTags: z19.array(z19.string().min(1)).optional().describe(
       "Frontmatter tags whose records stay out of the block. The base stays pinned and stays readable by tool; resolved like the budgets."
     ),
-    format: z18.enum(["markdown", "json"]).optional().describe(
+    format: z19.enum(["markdown", "json"]).optional().describe(
       "CLI envelope for hook protocols that require strict JSON on stdout. MCP callers omit this \u2014 the block itself is identical."
     ),
-    event: z18.string().optional().describe(
+    event: z19.string().optional().describe(
       "hookEventName stamped into the JSON envelope. Only meaningful with format=json."
     )
   }),
@@ -6209,20 +6302,20 @@ var contextCommand = define({
 });
 
 // src/commands/doctor.ts
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 
 // src/commands/reassess.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 var reassessCommand = define({
   name: "reassess",
   tool: "kb_reassess",
   usage: "reassess <concept-id> [--repo-root <path>] [--with-diff]",
   description: "One drifted record, as something to judge: its claim, each anchor's drift class, the old-vs-new span diff, and the records that depend on it. Formatting-only drift is dropped. Empty when there is nothing to reassess. Writes: relocates moved anchors, keeping their hash; never verifies, supersedes, or changes standing.",
-  input: z19.object({
+  input: z20.object({
     bundlePath,
     conceptId,
     repoRoot: REPO_ROOT,
-    withDiff: z19.boolean().optional().describe(
+    withDiff: z20.boolean().optional().describe(
       "Recover each anchor's committed span and render the diff. Reads git history."
     )
   }),
@@ -6367,13 +6460,13 @@ function at(file, symbol) {
 }
 
 // src/commands/doctor.ts
-var days = (what, fallback) => z20.number().int().positive().optional().describe(`${what} Defaults to ${fallback}.`);
+var days = (what, fallback) => z21.number().int().positive().optional().describe(`${what} Defaults to ${fallback}.`);
 var doctorCommand = define({
   name: "doctor",
   tool: "kb_doctor",
   usage: "doctor [--expiring-days N] [--unverified-days N] [--aging-days N] [--repo-root PATH] [--offline] [--strict] [--drifted [--with-diff]]",
   description: "Read-only health sweep: expired, expiring, unverified, aging, orphaned, broken-supersession, superseded-but-cited, drifted and unchecked anchors. Every group is reported even when empty; nothing is written or re-stamped. `drifted` narrows it to a reassessment packet per drifted record, `with_diff` adding each anchor's old-vs-new span.",
-  input: z20.object({
+  input: z21.object({
     bundlePath,
     repoRoot: REPO_ROOT,
     expiringDays: days(
@@ -6388,16 +6481,16 @@ var doctorCommand = define({
       "How long a record may stay `open` or `proposed` before `aging` reports it, in days.",
       DEFAULT_AGING_DAYS
     ),
-    offline: z20.boolean().optional().describe(
+    offline: z21.boolean().optional().describe(
       "Read foreign anchors from the local repo cache only, never fetching."
     ),
-    strict: z20.boolean().optional().describe(
+    strict: z21.boolean().optional().describe(
       "Turn an expired record into a non-zero exit for the CLI. No effect on the report itself."
     ),
-    drifted: z20.boolean().optional().describe(
+    drifted: z21.boolean().optional().describe(
       "Report only drift, as a reassessment packet per record: claim, per-anchor class, and what depends on it."
     ),
-    withDiff: z20.boolean().optional().describe(
+    withDiff: z21.boolean().optional().describe(
       "With `drifted`: recover each anchor's committed span and render the old-vs-new diff. Reads git history."
     )
   }),
@@ -6581,7 +6674,7 @@ import {
   writeFile as writeFile4
 } from "fs/promises";
 import { join as join7 } from "path";
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 var NUMBERED = /^(\d{4})-(.+)\.md$/;
 var MARKER = "<!-- strauss-kb export: ";
 var exportCommand = define({
@@ -6589,10 +6682,10 @@ var exportCommand = define({
   tool: "kb_export",
   usage: "export --format madr --to <dir>",
   description: "Write the base's decisions out as numbered MADR files, one per decision, for a repository that keeps ADRs of its own. Numbering is by slug, so a re-run rewrites its own files in place. A superseded decision is exported with what replaced it.",
-  input: z21.object({
+  input: z22.object({
     bundlePath,
-    format: z21.enum(["madr"]).describe("Output layout. `madr` is the only one so far."),
-    to: z21.string().min(1).describe("Directory the ADR files are written into.")
+    format: z22.enum(["madr"]).describe("Output layout. `madr` is the only one so far."),
+    to: z22.string().min(1).describe("Directory the ADR files are written into.")
   }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
@@ -6714,19 +6807,19 @@ function bodySections(body) {
 }
 
 // src/commands/impact.ts
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 var impactCommand = define({
   name: "impact",
   tool: "kb_impact",
   usage: "impact <concept-id> [--depth N] [--rels a,b]",
   description: "What breaks if this record changes: its transitive set of dependants, each with its standing. Each rel declares which of its ends depends on the other, and the walk follows each rel in its own direction. Naming `related_to` or an unknown rel in `rels` is an error. kb_backlinks gives one flat hop.",
-  input: z22.object({
+  input: z23.object({
     bundlePath,
     conceptId,
-    depth: z22.number().int().positive().optional().describe(
+    depth: z23.number().int().positive().optional().describe(
       "Hops out from the record. Unbounded when omitted; a walk this cuts reports truncated: true."
     ),
-    rels: z22.array(z22.enum(KB_CAUSAL_LINK_RELS)).optional().describe(
+    rels: z23.array(z23.enum(KB_CAUSAL_LINK_RELS)).optional().describe(
       "Narrow which rels the walk follows. Defaults to every rel that carries a dependence \u2014 all but related_to."
     )
   }),
@@ -6747,15 +6840,15 @@ var impactCommand = define({
 });
 
 // src/commands/list.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 var listCommand = define({
   name: "list",
   tool: "kb_list",
   usage: "list [type] [--tag T]...",
   description: "Every record, optionally one type or tag. For enumerating; use kb_query for a question.",
-  input: z23.object({
+  input: z24.object({
     bundlePath,
-    type: z23.enum(KB_RECORD_TYPES).optional(),
+    type: z24.enum(KB_RECORD_TYPES).optional(),
     tags: TAGS
   }),
   fromArgv: (argv, path) => {
@@ -6779,17 +6872,17 @@ var listCommand = define({
 });
 
 // src/commands/load.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 var loadCommand = define({
   name: "load",
   tool: "kb_load",
   usage: "load [type] [--budget N | --all] [--repo-root PATH]",
   description: "Load the whole base, each record with its standing \u2014 call it first, at the point of use, since compaction drops it. Superseded records arrive as stubs; kb_trace has the history. Over budget it refuses: kb_catalog, then kb_pack, or narrow with `type`; `all` bypasses. Never read record files directly \u2014 only kb_* tools resolve supersession. `digest` stamps the base's content, so hooks know when to reload.",
-  input: z24.object({
+  input: z25.object({
     bundlePath,
-    type: z24.enum(KB_RECORD_TYPES).optional(),
-    budgetTokens: z24.number().int().positive().optional().describe("Approximate token ceiling. Defaults to 25000."),
-    all: z24.boolean().optional().describe(
+    type: z25.enum(KB_RECORD_TYPES).optional(),
+    budgetTokens: z25.number().int().positive().optional().describe("Approximate token ceiling. Defaults to 25000."),
+    all: z25.boolean().optional().describe(
       "Loads the entire base regardless of size, bypassing the token budget; mutually exclusive with budgetTokens."
     ),
     repoRoot: REPO_ROOT
@@ -6831,25 +6924,25 @@ var loadCommand = define({
 });
 
 // src/commands/log.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 var logCommand = define({
   name: "log",
   tool: "kb_log",
   usage: "log",
   description: "Who touched what, and when. Append-only; malformed lines are reported, never repaired.",
-  input: z25.object({ bundlePath }),
+  input: z26.object({ bundlePath }),
   fromArgv: (_argv, path) => ({ bundlePath: path }),
   run: ({ store }, { bundlePath: path }) => store.readLog(path)
 });
 
 // src/commands/no-decision.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 var noDecisionCommand = define({
   name: "no-decision",
   tool: "kb_no_decision",
   usage: "no-decision <reason...>",
   description: "Record in one sentence that a piece of work had nothing to decide. Idempotent.",
-  input: z26.object({ bundlePath, reason: z26.string().min(1) }),
+  input: z27.object({ bundlePath, reason: z27.string().min(1) }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
     reason: argv.slice(1).join(" ").trim()
@@ -6866,20 +6959,20 @@ var noDecisionCommand = define({
 });
 
 // src/commands/pack.ts
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 var packCommand = define({
   name: "pack",
   tool: "kb_pack",
   usage: "pack <conceptId> [--hops N] [--max-nodes N] [--budget N]",
   description: "Bounded neighbourhood around one record: within `hops`, ranked, cut to `maxNodes`, with every cut record named under Excluded. Use when the base is over kb_load's budget and the work centres on a record you can name. Refuses over budget rather than truncating. Everything below the header is byte-stable across runs. Resolves supersession like kb_load.",
-  input: z27.object({
+  input: z28.object({
     bundlePath,
     conceptId,
-    hops: z27.number().int().positive().optional().describe("How far from the root the walk may reach. Defaults to 2."),
-    maxNodes: z27.number().int().positive().optional().describe(
+    hops: z28.number().int().positive().optional().describe("How far from the root the walk may reach. Defaults to 2."),
+    maxNodes: z28.number().int().positive().optional().describe(
       "How many records the pack may hold, root included. Defaults to 20."
     ),
-    budgetTokens: z27.number().int().positive().optional().describe(
+    budgetTokens: z28.number().int().positive().optional().describe(
       "Approximate token ceiling over what is actually emitted. Defaults to 25000."
     )
   }),
@@ -6966,22 +7059,22 @@ function warningLabel(warning) {
 }
 
 // src/commands/pin.ts
-import { z as z28 } from "zod";
+import { z as z29 } from "zod";
 var pinCommand = define({
   name: "pin",
   tool: "kb_pin",
   usage: "pin [bundle-path] [--mode full|index] [--profiles a,b] [--local|--user] [--frozen|--unfreeze]",
   description: "Pin a base into a workspace manifest so kb_context surfaces it. Layers, nearest wins: project `.strauss/kb-pins.json` (default), `--local` (personal, gitignored), `--user` (`~/.strauss`). Idempotent; `--mode full|index`, `--profiles`, `--frozen`/`--unfreeze` update only those fields. A path with no records pins with a warning. Never touches the base itself.",
-  input: z28.object({
+  input: z29.object({
     bundlePath,
-    mode: z28.enum(["full", "index"]).optional().describe(
+    mode: z29.enum(["full", "index"]).optional().describe(
       "full: always emit this base's records whole (still under the block budget); index: never upgrade. Absent: the profile's full-under threshold decides."
     ),
-    profiles: z28.array(z28.string()).optional().describe("Context profiles this pin surfaces in. Absent: all of them."),
-    layer: z28.enum(["project", "local", "user"]).optional().describe(
+    profiles: z29.array(z29.string()).optional().describe("Context profiles this pin surfaces in. Absent: all of them."),
+    layer: z29.enum(["project", "local", "user"]).optional().describe(
       "Which manifest to write: project (committed, default), local (personal, gitignored), user (~/.strauss, every workspace)."
     ),
-    frozen: z28.boolean().optional().describe(
+    frozen: z29.boolean().optional().describe(
       "true: the base is concluded \u2014 writes against it refuse while pinned. false: lift a freeze."
     )
   }),
@@ -7010,29 +7103,29 @@ var pinCommand = define({
 });
 
 // src/commands/pins.ts
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 var pinsCommand = define({
   name: "pins",
   tool: "kb_pins",
   usage: "pins",
   description: "Every pinned base across the manifest layers, with its layer and whether it resolves to records. Takes no bundlePath.",
-  input: z29.object({}),
+  input: z30.object({}),
   fromArgv: () => ({}),
   run: ({ store }) => listPins(store, process.cwd())
 });
 
 // src/commands/query.ts
-import { z as z30 } from "zod";
+import { z as z31 } from "zod";
 var queryCommand = define({
   name: "query",
   tool: "kb_query",
   usage: "query <text...> [--tag T]... [--repo-root PATH]",
   description: "Search; every hit carries its standing. Flagged, never filtered: a superseded hit returns with its replacement, a rejected one is marked. Prefer kb_load when the base fits its budget \u2014 a full read beats search. Results are volatile: place them at the tail, not the cached prefix. Never read record files directly.",
-  input: z30.object({
+  input: z31.object({
     bundlePath,
-    text: z30.string().optional(),
-    type: z30.enum(KB_RECORD_TYPES).optional(),
-    includeNonCurrent: z30.boolean().optional(),
+    text: z31.string().optional(),
+    type: z31.enum(KB_RECORD_TYPES).optional(),
+    includeNonCurrent: z31.boolean().optional(),
     tags: TAGS,
     repoRoot: REPO_ROOT
   }),
@@ -7066,43 +7159,43 @@ var queryCommand = define({
 });
 
 // src/commands/read-index.ts
-import { z as z31 } from "zod";
+import { z as z32 } from "zod";
 var readIndexCommand = define({
   name: "index",
   tool: "kb_index",
   usage: "index",
   description: "The index \u2014 title, type, status, description per record \u2014 rebuilt if stale. Cheapest re-orientation after compaction: call it (or kb_context) first, then kb_load or fetch by id.",
-  input: z31.object({ bundlePath }),
+  input: z32.object({ bundlePath }),
   fromArgv: (_argv, path) => ({ bundlePath: path }),
   run: ({ store }, { bundlePath: path }) => store.readIndex(path)
 });
 
 // src/commands/schema.ts
-import { z as z32 } from "zod";
+import { z as z33 } from "zod";
 var schemaCommand = define({
   name: "schema",
   tool: "kb_schema",
   usage: "schema",
   description: "JSON Schema for frontmatter, write input, and log entries, generated from the enforcing code.",
-  input: z32.object({}),
+  input: z33.object({}),
   fromArgv: () => ({}),
   run: () => Promise.resolve(kbJsonSchemas())
 });
 
 // src/commands/stamp.ts
 import { readFile as readFile7 } from "fs/promises";
-import { z as z33 } from "zod";
+import { z as z34 } from "zod";
 var DIGEST = /^[0-9a-f]{64}$/;
 var stampCommand = define({
   name: "stamp",
   tool: "kb_stamp",
   usage: "stamp [--bundle PATH] [--since DIGEST|FILE]",
   description: "Content stamp of a base \u2014 `load`'s digest, record counts, per-record digests, how many records have drifted anchors \u2014 without any bodies. Takes no bundlePath to stamp every pinned base. With `since`, reports only the bases that moved, naming the changed ids. Reads, never writes.",
-  input: z33.object({
-    bundlePath: z33.string().min(1).optional().describe(
+  input: z34.object({
+    bundlePath: z34.string().min(1).optional().describe(
       "Absolute path to one knowledge base. Omit to stamp every pinned base."
     ),
-    since: z33.string().min(1).optional().describe(
+    since: z34.string().min(1).optional().describe(
       "Prior digest, or path to a prior `stamp --json`; only moved bases return, with changed ids when the baseline is a file."
     )
   }),
@@ -7188,16 +7281,16 @@ async function readBaseline(since) {
 }
 
 // src/commands/status.ts
-import { z as z34 } from "zod";
+import { z as z35 } from "zod";
 var statusCommand = define({
   name: "status",
   tool: "kb_status",
   usage: "status <concept-id> <status>",
   description: "Move a record's status. Compare-and-swap: a concurrent change fails instead of being overwritten.",
-  input: z34.object({
+  input: z35.object({
     bundlePath,
     conceptId,
-    status: z34.enum(KB_RECORD_STATUSES)
+    status: z35.enum(KB_RECORD_STATUSES)
   }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
@@ -7212,13 +7305,13 @@ var statusCommand = define({
 });
 
 // src/commands/supersede.ts
-import { z as z35 } from "zod";
+import { z as z36 } from "zod";
 var supersedeCommand = define({
   name: "supersede",
   tool: "kb_supersede",
   usage: "supersede <concept-id> <replacement-id>",
   description: "Mark a record superseded by another, linked in both directions. Use instead of editing a record whose meaning changed.",
-  input: z35.object({ bundlePath, conceptId, replacementId: conceptId }),
+  input: z36.object({ bundlePath, conceptId, replacementId: conceptId }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
     conceptId: argv[1],
@@ -7232,7 +7325,7 @@ var supersedeCommand = define({
 });
 
 // src/commands/sweep.ts
-import { z as z36 } from "zod";
+import { z as z37 } from "zod";
 var TERMINAL = [
   "resolved",
   "rejected",
@@ -7243,15 +7336,15 @@ var sweepCommand = define({
   tool: "kb_sweep",
   usage: "sweep --tag <tag> --terminal [--dry-run]",
   description: "Delete tagged records that are resolved, rejected or superseded. Refuses without --tag, keeps any record a surviving record still points at, and logs each deletion.",
-  input: z36.object({
+  input: z37.object({
     bundlePath,
-    tag: z36.string({ error: "sweep needs --tag: it never sweeps a whole base" }).min(1).describe("Only records carrying this tag are considered."),
-    terminal: z36.literal(true, {
+    tag: z37.string({ error: "sweep needs --tag: it never sweeps a whole base" }).min(1).describe("Only records carrying this tag are considered."),
+    terminal: z37.literal(true, {
       error: "sweep needs --terminal: it deletes only settled records"
     }).describe(
       "Required. Names the only scope sweep deletes: resolved, rejected and superseded records."
     ),
-    dryRun: z36.boolean().optional().describe("Report what would go, and delete nothing.")
+    dryRun: z37.boolean().optional().describe("Report what would go, and delete nothing.")
   }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
@@ -7368,16 +7461,16 @@ function renderSweep(result) {
 }
 
 // src/commands/sync-instructions.ts
-import { z as z37 } from "zod";
+import { z as z38 } from "zod";
 var syncInstructionsCommand = define({
   name: "sync-instructions",
   usage: "sync-instructions <file> [--profile NAME] [--budget N] [--full-under N]",
   description: "CLI-only: plant the kb_context block between sentinel comments in AGENTS.md or CLAUDE.md, idempotently.",
-  input: z37.object({
-    file: z37.string().min(1).describe("The instruction file to edit in place."),
-    budgetTokens: z37.number().int().positive().optional(),
-    fullUnderTokens: z37.number().int().positive().optional(),
-    profile: z37.string().optional()
+  input: z38.object({
+    file: z38.string().min(1).describe("The instruction file to edit in place."),
+    budgetTokens: z38.number().int().positive().optional(),
+    fullUnderTokens: z38.number().int().positive().optional(),
+    profile: z38.string().optional()
   }),
   fromArgv: (argv) => {
     const budget = argvFlag(argv, "--budget");
@@ -7403,17 +7496,17 @@ var syncInstructionsCommand = define({
 });
 
 // src/commands/trace.ts
-import { z as z38 } from "zod";
+import { z as z39 } from "zod";
 var traceCommand = define({
   name: "trace",
   tool: "kb_trace",
   usage: "trace <concept-id> [edges...]",
   description: 'Timeline of how a position was reached, ordered by write time, following supersession, shared anchors and shared sources. Includes rejected, draft and superseded records \u2014 in a history they are the content. For "why is it like this"; kb_load answers "what holds now".',
-  input: z38.object({
+  input: z39.object({
     bundlePath,
     conceptId,
-    edges: z38.array(z38.enum(TRACE_EDGES)).optional(),
-    depth: z38.number().int().positive().optional()
+    edges: z39.array(z39.enum(TRACE_EDGES)).optional(),
+    depth: z39.number().int().positive().optional()
   }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
@@ -7435,37 +7528,37 @@ var traceCommand = define({
 });
 
 // src/commands/types.ts
-import { z as z39 } from "zod";
+import { z as z40 } from "zod";
 var typesCommand = define({
   name: "types",
   tool: "kb_types",
   usage: "types",
   description: "The twelve record types with their purpose, body sections, and starting status. Read this before writing rather than guessing headings \u2014 a section the type does not define is rejected.",
-  input: z39.object({}),
+  input: z40.object({}),
   fromArgv: () => ({}),
   run: () => Promise.resolve(RECORD_TYPES)
 });
 
 // src/commands/unpin.ts
-import { z as z40 } from "zod";
+import { z as z41 } from "zod";
 var unpinCommand = define({
   name: "unpin",
   tool: "kb_unpin",
   usage: "unpin [bundle-path]",
   description: "Remove a base from every manifest layer that holds it. Reports the layers touched.",
-  input: z40.object({ bundlePath }),
+  input: z41.object({ bundlePath }),
   fromArgv: (argv, path) => ({ bundlePath: argv[1] ?? path }),
   run: (_ctx, { bundlePath: path }) => unpinBase(process.cwd(), path)
 });
 
 // src/commands/validate.ts
-import { z as z41 } from "zod";
+import { z as z42 } from "zod";
 var validateCommand = define({
   name: "validate",
   tool: "kb_validate",
   usage: "validate",
   description: "Check pointers no single record can see: supersession links that disagree between the two records, typed causal links, and assumptions that cite sources. Each finding carries a severity: errors fail the exit code, warnings do not.",
-  input: z41.object({ bundlePath }),
+  input: z42.object({ bundlePath }),
   fromArgv: (_argv, path) => ({ bundlePath: path }),
   run: async ({ store }, { bundlePath: path }) => validateBundle(await store.list(path)),
   // Warnings never fail the exit code; every other severity does.
@@ -7475,16 +7568,16 @@ var validateCommand = define({
 });
 
 // src/commands/verify.ts
-import { z as z42 } from "zod";
+import { z as z43 } from "zod";
 var verifyCommand = define({
   name: "verify",
   tool: "kb_verify",
   usage: "verify <concept-id> --note <text>",
   description: "Append a verified[] event: who checked, when, and what was found. Append-only. A record's own generator is refused unless the actor is `human:`-prefixed.",
-  input: z42.object({
+  input: z43.object({
     bundlePath,
     conceptId,
-    note: z42.string().refine((s) => s.trim().length > 0, {
+    note: z43.string().refine((s) => s.trim().length > 0, {
       message: "note must say what the check found"
     })
   }),
@@ -7504,15 +7597,15 @@ var verifyCommand = define({
 });
 
 // src/commands/write.ts
-import { z as z43 } from "zod";
+import { z as z44 } from "zod";
 var writeCommand = define({
   name: "write",
   tool: "kb_write",
   usage: "write <type> < record.json",
   description: "Write one record. Search first \u2014 a duplicate concept id is rejected, not overwritten; kb_types lists each type's sections. An unsourced claim is an `assumption` with assumption: true, never a vague `fact`. Conflicting records get a `risk`, `open-question`, or superseding `decision`. Prefer a new short record over overloading one. Never delete; supersede.",
-  input: z43.object({
+  input: z44.object({
     bundlePath,
-    type: z43.enum(KB_RECORD_TYPES),
+    type: z44.enum(KB_RECORD_TYPES),
     input: composeInputSchema
   }),
   fromArgv: async (argv, path, stdin) => ({
@@ -7536,13 +7629,13 @@ var writeCommand = define({
 });
 
 // src/commands/write-decision.ts
-import { z as z44 } from "zod";
+import { z as z45 } from "zod";
 var writeDecisionCommand = define({
   name: "write-decision",
   tool: "kb_write_decision",
   usage: "write-decision < decision.json",
   description: "Write a decision, with `alternative` (what was rejected and why) and `impact` as fields. Record one when a later reader would otherwise simplify the constraint away; skip when the diff already answers it. `sources` for material read, `anchors` for code, `relatedConceptIds` for records.",
-  input: z44.object({ bundlePath, input: decisionInputSchema }),
+  input: z45.object({ bundlePath, input: decisionInputSchema }),
   fromArgv: async (_argv, path, stdin) => ({
     bundlePath: path,
     input: JSON.parse(await stdin())
@@ -8714,7 +8807,7 @@ function typeRank(record) {
 }
 
 // src/version.ts
-var VERSION = true ? "0.1.22" : "0.0.0-dev";
+var VERSION = true ? "0.1.23" : "0.0.0-dev";
 
 export {
   isCanonicalRepoUrl,
@@ -8869,4 +8962,4 @@ export {
   KbStore,
   VERSION
 };
-//# sourceMappingURL=chunk-AEO5U42S.js.map
+//# sourceMappingURL=chunk-XENLCPL5.js.map