@saasontools/strauss-kb 0.1.15 → 0.1.17

package/dist/mcp-main.cjs

@@ -23,6 +23,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// ../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.26_supports-color@8.1.1_typescript@6.0.3_yaml@2.9.0/node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
 // src/mcp.ts
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
@@ -78,7 +82,13 @@ var kbAnchorSchema = import_zod.z.object({
   /** ISO 8601 timestamp of the last successful resolution. */
   resolved_at: import_zod.z.string().min(1).optional(),
   /** Line count of the text the hash was taken over. */
-  lines: import_zod.z.number().int().positive().optional()
+  lines: import_zod.z.number().int().positive().optional(),
+  /**
+   * Which resolver produced the hashed span. Absent means an anchor stamped
+   * before resolvers were named, which is read as `regex` — the only one
+   * there was. A hash from a different resolver is drift, not a match.
+   */
+  resolver: import_zod.z.enum(["tree-sitter", "regex"]).optional()
 }).strict();
 var kbLinkSchema = import_zod.z.object({
   target: import_zod.z.string().min(1),
@@ -442,7 +452,7 @@ function composeNoDecisionRecord(reason, writtenBy, writtenAt) {
 }
 
 // src/commands/anchor-resolve.ts
-var import_zod6 = require("zod");
+var import_zod7 = require("zod");
 
 // src/concurrency.ts
 var DEFAULT_IO_CONCURRENCY = 16;
@@ -739,18 +749,18 @@ async function readOneRepo(repo, url, declared, context) {
   if (!repoUrlIsSafe(url)) return all({ ok: false, reason: "repo-invalid" });
   const cache = cachePathFor(repo, context.cacheDir);
   if (!cache) return all({ ok: false, reason: "remote-unreachable" });
-  const rejected = /* @__PURE__ */ new Map();
+  const rejected2 = /* @__PURE__ */ new Map();
   const usable = [];
   for (const want of wants) {
     const reason = wantReason(want);
     if (reason)
-      rejected.set(wantKey(repo, want.ref, want.file), { ok: false, reason });
+      rejected2.set(wantKey(repo, want.ref, want.file), { ok: false, reason });
     else usable.push(want);
   }
-  if (!usable.length) return rejected;
+  if (!usable.length) return rejected2;
   wants = usable;
   const opened = await openCache(cache, url, context);
-  if (opened) return new Map([...rejected, ...all(opened)]);
+  if (opened) return new Map([...rejected2, ...all(opened)]);
   const wantsDefault = wants.some((want) => want.ref === void 0);
   const branch = wantsDefault ? await defaultBranch(cache, context) : {};
   const revs = /* @__PURE__ */ new Map();
@@ -777,7 +787,7 @@ async function readOneRepo(repo, url, declared, context) {
     }
   );
   return new Map([
-    ...rejected,
+    ...rejected2,
     ...wants.map(
       (want, at) => [wantKey(repo, want.ref, want.file), reads[at]]
     )
@@ -829,13 +839,13 @@ async function defaultBranch(cache, context) {
     if (!listed.ok) {
       const reason = transportReason(listed.stderr);
       if (reason !== "ref-not-found") {
-        const cached2 = await cachedBranch(cache);
-        return cached2 ? { name: cached2 } : { reason };
+        const cached3 = await cachedBranch(cache);
+        return cached3 ? { name: cached3 } : { reason };
       }
     }
   }
-  const cached = await cachedBranch(cache);
-  if (cached) return { name: cached };
+  const cached2 = await cachedBranch(cache);
+  if (cached2) return { name: cached2 };
   return {
     reason: context.offline ? "remote-unreachable" : "default-branch-unknown"
   };
@@ -862,8 +872,8 @@ async function ensureRev(cache, rev, context) {
       cwd: cache
     }
   );
-  const cached = have.ok && have.stdout.trim().length > 0;
-  if (cached && (context.offline || IMMUTABLE_REV.test(rev))) return void 0;
+  const cached2 = have.ok && have.stdout.trim().length > 0;
+  if (cached2 && (context.offline || IMMUTABLE_REV.test(rev))) return void 0;
   if (context.offline) return { ok: false, reason: "remote-unreachable" };
   const fetched = await git(
     [
@@ -879,7 +889,7 @@ async function ensureRev(cache, rev, context) {
   );
   if (!fetched.ok) {
     const reason = transportReason(fetched.stderr);
-    if (cached && reason !== "ref-not-found") return void 0;
+    if (cached2 && reason !== "ref-not-found") return void 0;
     return { ok: false, reason };
   }
   const head = await git(["rev-parse", "FETCH_HEAD"], { cwd: cache });
@@ -994,63 +1004,577 @@ async function readAnchorFiles(files, read, concurrency = DEFAULT_IO_CONCURRENCY
 }
 
 // src/anchor-resolver/resolver.ts
+var import_node_crypto3 = require("crypto");
+
+// src/tree-sitter-resolver/languages.ts
+var import_node_path5 = require("path");
+
+// src/grammars/index.ts
+var import_promises4 = require("fs/promises");
+
+// src/grammars/store.ts
 var import_node_crypto = require("crypto");
+var import_promises3 = require("fs/promises");
+var import_node_os2 = require("os");
+var import_node_path3 = require("path");
+function grammarsCacheRoot(override) {
+  return override ?? process.env["STRAUSS_KB_GRAMMARS_DIR"] ?? (0, import_node_path3.join)((0, import_node_os2.homedir)(), ".strauss", "grammars");
+}
+function grammarCachePath(root, language, sha2564, extension = "wasm") {
+  return (0, import_node_path3.join)(root, language, `${sha2564.slice(0, 12)}.${extension}`);
+}
+function sha256(bytes) {
+  return (0, import_node_crypto.createHash)("sha256").update(bytes).digest("hex");
+}
+function matches(bytes, entry) {
+  if (entry.bytes !== void 0 && bytes.byteLength !== entry.bytes)
+    return false;
+  return sha256(bytes) === entry.sha256;
+}
+async function verifyCached(path, entry) {
+  let bytes;
+  try {
+    bytes = await (0, import_promises3.readFile)(path);
+  } catch {
+    return false;
+  }
+  if (matches(bytes, entry)) return true;
+  await (0, import_promises3.rm)(path, { force: true });
+  return false;
+}
+async function writeCached(path, bytes) {
+  await (0, import_promises3.mkdir)((0, import_node_path3.dirname)(path), { recursive: true });
+  const temporary = `${path}.${process.pid}.${(0, import_node_crypto.randomBytes)(4).toString("hex")}.tmp`;
+  try {
+    await (0, import_promises3.writeFile)(temporary, bytes);
+    await (0, import_promises3.rename)(temporary, path);
+  } catch (error) {
+    await (0, import_promises3.rm)(temporary, { force: true });
+    throw error;
+  }
+}
+
+// src/grammars/fetch.ts
+var ATTEMPTS = 3;
+var BACKOFF_MS = 250;
+function grammarUrl(url, override) {
+  const base2 = grammarsBaseUrl(override);
+  if (!base2) return url;
+  let root = base2;
+  while (root.endsWith("/")) root = root.slice(0, -1);
+  const pinned = new URL(url);
+  return `${root}${pinned.pathname}${pinned.search}`;
+}
+function grammarsBaseUrl(override) {
+  return override ?? process.env["STRAUSS_KB_GRAMMARS_URL"];
+}
+async function downloadPart(url, name, entry, options = {}) {
+  const log = options.log ?? ((line) => void process.stderr.write(line));
+  const weight = entry.bytes === void 0 ? "" : ` (${size(entry.bytes)} from manifest)`;
+  log(`strauss-kb: downloading ${name}${weight} from ${url}
+`);
+  let cause = "";
+  for (let attempt = 1; attempt <= ATTEMPTS; attempt++) {
+    const outcome = await attemptDownload(url, entry, options.fetchTimeoutMs);
+    if ("bytes" in outcome) return outcome;
+    cause = outcome.cause;
+    log(
+      `strauss-kb: ${name} attempt ${attempt}/${ATTEMPTS} failed: ${cause}
+`
+    );
+    if (!outcome.retry) break;
+    if (attempt < ATTEMPTS) await pause(BACKOFF_MS * attempt);
+  }
+  log(`strauss-kb: ${name} not downloaded: ${cause}
+`);
+  return { cause };
+}
+async function attemptDownload(url, entry, timeoutMs) {
+  try {
+    const response = await fetch(url, {
+      signal: AbortSignal.timeout(fetchTimeoutMs(timeoutMs))
+    });
+    if (!response.ok) {
+      return {
+        cause: `HTTP ${response.status}`,
+        retry: response.status >= 500 || response.status === 429
+      };
+    }
+    const bytes = new Uint8Array(await response.arrayBuffer());
+    if (!matches(bytes, entry))
+      return { cause: "sha256 mismatch", retry: false };
+    return { bytes };
+  } catch (error) {
+    const timedOut = error instanceof Error && (error.name === "TimeoutError" || error.name === "AbortError");
+    return { cause: timedOut ? "timeout" : "network error", retry: true };
+  }
+}
+function size(bytes) {
+  return bytes >= 1024 * 1024 ? `${(bytes / (1024 * 1024)).toFixed(1)} MB` : `${Math.round(bytes / 1024)} KB`;
+}
+function pause(ms) {
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
+}
+
+// src/grammars/manifest.ts
+var import_node_fs = require("fs");
+var import_node_path4 = require("path");
+var import_node_url = require("url");
+
+// src/grammars/model.ts
+var import_zod4 = require("zod");
+var sha2562 = import_zod4.z.string().regex(/^[0-9a-f]{64}$/);
+var grammarWasmSchema = import_zod4.z.object({
+  url: import_zod4.z.string().min(1),
+  sha256: sha2562,
+  bytes: import_zod4.z.number().int().positive()
+});
+var grammarTagsSchema = import_zod4.z.object({ url: import_zod4.z.string().min(1), sha256: sha2562 });
+var grammarPackSchema = import_zod4.z.object({
+  package: import_zod4.z.string().min(1),
+  wasm: grammarWasmSchema,
+  tags: import_zod4.z.array(grammarTagsSchema),
+  license: import_zod4.z.string().min(1),
+  extensions: import_zod4.z.array(import_zod4.z.string().min(1))
+});
+var grammarManifestSchema = import_zod4.z.object({
+  /** The runtime the packs were proved against. */
+  webTreeSitter: import_zod4.z.string().min(1),
+  linguist: import_zod4.z.object({ tag: import_zod4.z.string().min(1), commit: import_zod4.z.string().min(1) }),
+  packs: import_zod4.z.record(import_zod4.z.string().min(1), grammarPackSchema)
+});
+
+// src/grammars/manifest.ts
+var cached;
+function grammarManifest() {
+  cached ??= grammarManifestSchema.parse(
+    JSON.parse((0, import_node_fs.readFileSync)(grammarsDataPath("manifest.json"), "utf8"))
+  );
+  return cached;
+}
+function grammarsDataPath(...segments) {
+  let dir = (0, import_node_path4.dirname)((0, import_node_url.fileURLToPath)(importMetaUrl));
+  for (let up = 0; up < 5; up++) {
+    const candidate = (0, import_node_path4.join)(dir, "grammars");
+    if ((0, import_node_fs.existsSync)((0, import_node_path4.join)(candidate, "manifest.json")))
+      return (0, import_node_path4.join)(candidate, ...segments);
+    dir = (0, import_node_path4.dirname)(dir);
+  }
+  throw new Error("grammars/manifest.json is missing from the package");
+}
+
+// src/grammars/index.ts
+var inFlight = /* @__PURE__ */ new Map();
+var missing = /* @__PURE__ */ new Map();
+var uncompilable = /* @__PURE__ */ new Map();
+var rejected = /* @__PURE__ */ new Map();
+function grammarsDownloadDisabled() {
+  return process.env["STRAUSS_KB_GRAMMARS"] === "off";
+}
+async function ensureGrammar(language, options = {}) {
+  const pack2 = grammarManifest().packs[language];
+  if (!pack2) return null;
+  const root = grammarsCacheRoot(options.cacheRoot);
+  const wasm = grammarCachePath(root, language, pack2.wasm.sha256);
+  const key = `${wasm} ${grammarsBaseUrl(options.baseUrl) ?? ""}`;
+  const existing = inFlight.get(key);
+  if (existing) return existing;
+  const pending = (async () => {
+    const grammar = await ensurePart(
+      wasm,
+      `tree-sitter-${language}`,
+      pack2.wasm,
+      options
+    );
+    if (grammar !== true)
+      return miss(language, `grammar tree-sitter-${language}`, grammar);
+    const parts = [];
+    const total = pack2.tags.length;
+    for (const [at, part] of pack2.tags.entries()) {
+      const name = `${language} tags${total > 1 ? ` part ${at + 1}/${total}` : ""}`;
+      const path = grammarCachePath(root, language, part.sha256, "scm");
+      const held = await ensurePart(path, name, part, options);
+      if (held !== true) return miss(language, name, held);
+      parts.push(`; ${part.url}
+${lf(await (0, import_promises4.readFile)(path, "utf8"))}`);
+    }
+    missing.delete(language);
+    return { wasm, query: total ? parts.join("\n") : void 0 };
+  })();
+  inFlight.set(key, pending);
+  const result = await pending;
+  if (result === null) inFlight.delete(key);
+  return result;
+}
+async function ensurePart(path, name, entry, options) {
+  if (await verifyCached(path, entry)) return true;
+  if (options.offline === true || grammarsDownloadDisabled()) return {};
+  const download = await downloadPart(
+    grammarUrl(entry.url, options.baseUrl),
+    name,
+    entry,
+    options
+  );
+  if ("cause" in download) return { cause: download.cause };
+  await writeCached(path, download.bytes).catch(() => null);
+  return true;
+}
+function miss(language, subject, failure) {
+  missing.set(language, { subject, ...failure });
+  return null;
+}
+function lf(body) {
+  return body.replace(/\r\n/g, "\n");
+}
+function noteUncompilableQuery(language, cause) {
+  uncompilable.set(language, cause);
+}
+function noteRejectedGrammar(language, cause) {
+  rejected.set(language, cause);
+}
+function grammarHints() {
+  const manifest = grammarManifest();
+  const packs = manifest.packs;
+  const lines = /* @__PURE__ */ new Map();
+  for (const [language, { subject, cause }] of missing)
+    lines.set(
+      language,
+      `${subject} not cached${cause ? ` (${cause})` : ""}; run online once, or set STRAUSS_KB_GRAMMARS_DIR`
+    );
+  for (const [language, cause] of rejected)
+    lines.set(
+      language,
+      `${packs[language]?.package ?? `tree-sitter-${language}`} rejected by web-tree-sitter ${manifest.webTreeSitter}${cause ? `: ${cause}` : ""}; re-pin with pnpm grammars pin ${language}`
+    );
+  for (const [language, cause] of uncompilable)
+    lines.set(
+      language,
+      `tags query for ${language} does not compile against ${packs[language]?.package ?? `tree-sitter-${language}`}: ${cause}; re-pin with pnpm grammars pin ${language}`
+    );
+  return [...lines].sort(([a], [b]) => a.localeCompare(b)).map(([, line]) => line);
+}
+
+// src/tree-sitter-resolver/languages.ts
+var table;
+function extensionTable() {
+  const manifest = grammarManifest();
+  if (table?.of !== manifest)
+    table = {
+      of: manifest,
+      extensions: Object.fromEntries(
+        Object.entries(manifest.packs).flatMap(
+          ([language, pack2]) => pack2.extensions.map((extension) => [extension, language])
+        )
+      )
+    };
+  return table.extensions;
+}
+function hasQuery(language) {
+  return (grammarManifest().packs[language]?.tags.length ?? 0) > 0;
+}
+function languageForFile(file) {
+  const language = extensionTable()[(0, import_node_path5.extname)(file).toLowerCase()];
+  return language && hasQuery(language) ? language : void 0;
+}
+
+// src/tree-sitter-resolver/resolver.ts
+var import_node_crypto2 = require("crypto");
+var import_web_tree_sitter = require("web-tree-sitter");
+
+// src/tree-sitter-resolver/definitions.ts
+var SCOPE_ONLY = "reference.implementation";
+function index(tree, query) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const match of query.matches(tree.rootNode)) {
+    const nameNode = match.captures.find((capture) => capture.name === "name");
+    const defNode = match.captures.find(
+      (capture) => capture.name.startsWith("definition.") || capture.name === SCOPE_ONLY
+    );
+    if (!nameNode || !defNode) continue;
+    const candidate = {
+      node: defNode.node,
+      name: nameNode.node.text,
+      target: defNode.name !== SCOPE_ONLY
+    };
+    const existing = byName.get(nameNode.node.id);
+    if (existing && width(existing.node) <= width(candidate.node)) continue;
+    byName.set(nameNode.node.id, candidate);
+  }
+  const definitions = [...byName.values()];
+  return {
+    tree,
+    byNodeId: new Map(
+      definitions.map((definition) => [definition.node.id, definition])
+    ),
+    definitions
+  };
+}
+function select(parsed, wanted) {
+  const matches3 = parsed.definitions.filter(
+    (definition) => definition.target && endsWith(chainOf(definition, parsed.byNodeId), wanted)
+  );
+  if (matches3.length < 2) return matches3;
+  const bodied = matches3.filter(
+    (definition) => definition.node.childForFieldName("body") !== null
+  );
+  return bodied.length === 1 ? bodied : matches3;
+}
+function chainOf(definition, byNodeId) {
+  const chain = [definition.name];
+  const receiver = definition.node.childForFieldName("receiver");
+  const type = receiver && typeNameIn(receiver);
+  if (type) chain.unshift(type);
+  for (let node = definition.node.parent; node; node = node.parent) {
+    const enclosing = byNodeId.get(node.id);
+    if (enclosing && enclosing.node !== definition.node)
+      chain.unshift(enclosing.name);
+  }
+  return chain;
+}
+function typeNameIn(receiver) {
+  const stack = [receiver];
+  while (stack.length) {
+    const node = stack.pop();
+    if (node.type === "type_identifier") return node.text;
+    for (let at = 0; at < node.childCount; at++) {
+      const child = node.child(at);
+      if (child) stack.push(child);
+    }
+  }
+  return void 0;
+}
+function endsWith(chain, wanted) {
+  if (wanted.length > chain.length) return false;
+  const offset = chain.length - wanted.length;
+  return wanted.every((segment, at) => chain[offset + at] === segment);
+}
+function width(node) {
+  return node.endIndex - node.startIndex;
+}
+function spanOf(definition, source) {
+  let start = definition.node;
+  let end = definition.node;
+  for (let sibling = start.previousSibling; sibling?.type === "decorator"; sibling = sibling.previousSibling) {
+    start = sibling;
+  }
+  const parent = end.parent;
+  if (parent?.type === "export_statement" && parent.childForFieldName("declaration")?.id === end.id) {
+    start = parent;
+    end = parent;
+  }
+  const lines = source.split("\n");
+  const startLine = start.startPosition.row;
+  const endLine = end.endPosition.column === 0 && end.endPosition.row > startLine ? end.endPosition.row - 1 : end.endPosition.row;
+  return {
+    text: lines.slice(startLine, endLine + 1).join("\n"),
+    startLine: startLine + 1,
+    endLine: endLine + 1
+  };
+}
+
+// src/tree-sitter-resolver/resolver.ts
+var TREE_CACHE_LIMIT = 32;
+var TreeSitterResolver = class {
+  name = "tree-sitter";
+  grammars;
+  loaded = /* @__PURE__ */ new Map();
+  trees = /* @__PURE__ */ new Map();
+  parser;
+  initialized = false;
+  /** Cache effectiveness, for tests and for the latency numbers. */
+  stats = { parses: 0, cacheHits: 0 };
+  constructor(options = {}) {
+    this.grammars = options;
+  }
+  /**
+   * Loads the grammars these files need, once per language per process,
+   * downloading each one on first use.
+   *
+   * A grammar that will not load is remembered as unavailable rather than
+   * retried per anchor, and never throws: an unobtainable WASM is a finding.
+   */
+  async prepare(files) {
+    const wanted = /* @__PURE__ */ new Set();
+    for (const file of files) {
+      const language = languageForFile(file);
+      if (language && !this.loaded.has(language)) wanted.add(language);
+    }
+    if (!wanted.size) return;
+    if (!this.initialized) {
+      try {
+        await import_web_tree_sitter.Parser.init();
+        this.parser = new import_web_tree_sitter.Parser();
+        this.initialized = true;
+      } catch {
+        for (const language of wanted) this.loaded.set(language, null);
+        return;
+      }
+    }
+    const languages = [...wanted];
+    const loaded = await mapLimit(
+      languages,
+      Math.min(DEFAULT_IO_CONCURRENCY, languages.length),
+      (language) => this.load(language)
+    );
+    languages.forEach(
+      (language, at) => this.loaded.set(language, loaded[at] ?? null)
+    );
+  }
+  /**
+   * An unobtainable grammar, one this runtime refuses, and a query that will
+   * not compile are three faults with three repairs; all are reported through
+   * the grammars module so every hint has one home.
+   */
+  async load(language) {
+    let pack2;
+    try {
+      pack2 = await ensureGrammar(language, this.grammars);
+    } catch {
+      return null;
+    }
+    if (!pack2?.query) return null;
+    let grammar;
+    try {
+      grammar = await import_web_tree_sitter.Language.load(pack2.wasm);
+    } catch (error) {
+      noteRejectedGrammar(language, why(error));
+      return null;
+    }
+    try {
+      return { language: grammar, query: new import_web_tree_sitter.Query(grammar, pack2.query) };
+    } catch (error) {
+      noteUncompilableQuery(language, why(error));
+      return null;
+    }
+  }
+  /**
+   * Abstains on an extension with no grammar so the regex resolver gets a
+   * turn; reports `resolver-unavailable` when the grammar exists in principle
+   * but could not be loaded, because falling back there would silently trade a
+   * precise span for a guessed one.
+   */
+  attempt(source, symbol, file) {
+    const language = file ? languageForFile(file) : void 0;
+    if (!language) return { kind: "abstain" };
+    if (!this.loaded.has(language)) return { kind: "abstain" };
+    const loaded = this.loaded.get(language);
+    if (!loaded) return { kind: "unresolved", reason: "resolver-unavailable" };
+    const parsed = this.parse(language, loaded, source);
+    if (!parsed) return { kind: "unresolved", reason: "resolver-unavailable" };
+    const wanted = symbol.split(".").filter(Boolean);
+    if (!wanted.length)
+      return { kind: "unresolved", reason: "symbol-not-found" };
+    const matches3 = select(parsed, wanted);
+    if (!matches3.length)
+      return { kind: "unresolved", reason: "symbol-not-found" };
+    if (matches3.length > 1)
+      return { kind: "unresolved", reason: "symbol-ambiguous" };
+    return { kind: "resolved", span: spanOf(matches3[0], source) };
+  }
+  resolve(source, symbol, file) {
+    const attempt = this.attempt(source, symbol, file);
+    return attempt.kind === "resolved" ? attempt.span : null;
+  }
+  /** Parsed trees are keyed by content hash, so an unchanged file parses once. */
+  parse(language, loaded, source) {
+    const key = `${language}:${(0, import_node_crypto2.createHash)("sha256").update(source).digest("hex")}`;
+    const cached2 = this.trees.get(key);
+    if (cached2) {
+      this.stats.cacheHits += 1;
+      return cached2;
+    }
+    const parser = this.parser;
+    if (!parser) return null;
+    let parsed;
+    try {
+      parser.setLanguage(loaded.language);
+      const tree = parser.parse(source);
+      if (!tree) return null;
+      parsed = index(tree, loaded.query);
+    } catch {
+      return null;
+    }
+    this.stats.parses += 1;
+    if (this.trees.size >= TREE_CACHE_LIMIT) {
+      const oldest = this.trees.keys().next();
+      if (!oldest.done) {
+        this.trees.get(oldest.value)?.tree.delete();
+        this.trees.delete(oldest.value);
+      }
+    }
+    this.trees.set(key, parsed);
+    return parsed;
+  }
+  /** Drops cached trees. Grammars stay loaded — they are immutable. */
+  reset() {
+    for (const parsed of this.trees.values()) parsed.tree.delete();
+    this.trees.clear();
+    this.stats.parses = 0;
+    this.stats.cacheHits = 0;
+  }
+};
+function why(error) {
+  const text = error instanceof Error ? error.message : String(error);
+  return text || "no reason given";
+}
+
+// src/anchor-resolver/resolver.ts
 var PARENT_SCOPE_LINES = 50;
 var CLEAN_STATE = { blockComment: false, template: false };
 function stripLine(line, state) {
   let out = "";
-  let index = 0;
+  let index2 = 0;
   let { blockComment, template } = state;
-  while (index < line.length) {
-    const char = line[index];
-    const next = line[index + 1];
+  while (index2 < line.length) {
+    const char = line[index2];
+    const next = line[index2 + 1];
     if (blockComment) {
       if (char === "*" && next === "/") {
         blockComment = false;
-        index += 2;
+        index2 += 2;
         continue;
       }
-      index += 1;
+      index2 += 1;
       continue;
     }
     if (template) {
       if (char === "\\") {
-        index += 2;
+        index2 += 2;
         continue;
       }
       if (char === "`") template = false;
-      index += 1;
+      index2 += 1;
       continue;
     }
     if (char === "/" && next === "*") {
       blockComment = true;
-      index += 2;
+      index2 += 2;
       continue;
     }
     if (char === "/" && next === "/") break;
     if (char === "`") {
       template = true;
-      index += 1;
+      index2 += 1;
       continue;
     }
     if (char === "'" || char === '"') {
       const quote = char;
-      index += 1;
-      while (index < line.length) {
-        if (line[index] === "\\") {
-          index += 2;
+      index2 += 1;
+      while (index2 < line.length) {
+        if (line[index2] === "\\") {
+          index2 += 2;
           continue;
         }
-        if (line[index] === quote) {
-          index += 1;
+        if (line[index2] === quote) {
+          index2 += 1;
           break;
         }
-        index += 1;
+        index2 += 1;
       }
       continue;
     }
     out += char;
-    index += 1;
+    index2 += 1;
   }
   return { code: out, state: { blockComment, template } };
 }
@@ -1065,8 +1589,8 @@ function captureBraceBlock(lines, matchLine) {
   let depth = 0;
   let opened = false;
   let state = CLEAN_STATE;
-  for (let index = matchLine; index < lines.length; index++) {
-    const stripped = stripLine(lines[index] ?? "", state);
+  for (let index2 = matchLine; index2 < lines.length; index2++) {
+    const stripped = stripLine(lines[index2] ?? "", state);
     state = stripped.state;
     for (const char of stripped.code) {
       if (char === "{") {
@@ -1075,10 +1599,10 @@ function captureBraceBlock(lines, matchLine) {
       } else if (char === "}") {
         depth = Math.max(0, depth - 1);
       } else if (char === ";" && !opened) {
-        return span(lines, matchLine, index);
+        return span(lines, matchLine, index2);
       }
     }
-    if (opened && depth === 0) return span(lines, matchLine, index);
+    if (opened && depth === 0) return span(lines, matchLine, index2);
   }
   return null;
 }
@@ -1087,22 +1611,22 @@ function captureIndentedBlock(lines, matchLine) {
   const header = lines[matchLine] ?? "";
   const indent = header.length - header.trimStart().length;
   let headerEnd = -1;
-  for (let index = matchLine; index < lines.length && index <= matchLine + 20; index++) {
-    const code = stripLine(lines[index] ?? "", CLEAN_STATE).code.trimEnd();
+  for (let index2 = matchLine; index2 < lines.length && index2 <= matchLine + 20; index2++) {
+    const code = stripLine(lines[index2] ?? "", CLEAN_STATE).code.trimEnd();
     if (code.endsWith(":")) {
-      headerEnd = index;
+      headerEnd = index2;
       break;
     }
-    if (code.includes(":")) return span(lines, matchLine, index);
+    if (code.includes(":")) return span(lines, matchLine, index2);
   }
   if (headerEnd === -1) return null;
   let end = headerEnd;
-  for (let index = headerEnd + 1; index < lines.length; index++) {
-    const line = lines[index] ?? "";
+  for (let index2 = headerEnd + 1; index2 < lines.length; index2++) {
+    const line = lines[index2] ?? "";
     if (line.trim() === "") continue;
     const lineIndent = line.length - line.trimStart().length;
     if (lineIndent <= indent) break;
-    end = index;
+    end = index2;
   }
   return end === headerEnd ? null : span(lines, matchLine, end);
 }
@@ -1126,11 +1650,11 @@ var regexResolver = {
     const lines = source.split("\n");
     for (const tier of TIERS) {
       const pattern = tier(escaped);
-      let candidates = lines.map((line, index) => ({ line, index })).filter((entry) => pattern.test(entry.line)).map((entry) => entry.index);
+      let candidates = lines.map((line, index2) => ({ line, index: index2 })).filter((entry) => pattern.test(entry.line)).map((entry) => entry.index);
       if (!candidates.length) continue;
       if (parentPattern && candidates.length > 1) {
         const distances = candidates.map(
-          (index) => distanceToParent(lines, index, parentPattern)
+          (index2) => distanceToParent(lines, index2, parentPattern)
         );
         const nearest = Math.min(...distances);
         if (Number.isFinite(nearest)) {
@@ -1147,34 +1671,75 @@ var regexResolver = {
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function distanceToParent(lines, index, parent) {
-  const floor = Math.max(0, index - PARENT_SCOPE_LINES);
-  for (let at = index; at >= floor; at--) {
-    if (parent.test(lines[at] ?? "")) return index - at;
+function distanceToParent(lines, index2, parent) {
+  const floor = Math.max(0, index2 - PARENT_SCOPE_LINES);
+  for (let at = index2; at >= floor; at--) {
+    if (parent.test(lines[at] ?? "")) return index2 - at;
   }
   return Number.POSITIVE_INFINITY;
 }
 function hashAnchorText(text) {
-  return `sha256:${(0, import_node_crypto.createHash)("sha256").update(text.replace(/\r\n/g, "\n")).digest("hex")}`;
+  return `sha256:${(0, import_node_crypto3.createHash)("sha256").update(text.replace(/\r\n/g, "\n")).digest("hex")}`;
 }
-function resolveAnchor(source, anchor, resolver = regexResolver) {
+function resolveAnchorSpan(source, anchor, resolvers = [regexResolver]) {
   const normalized = source.replace(/\r\n/g, "\n");
   if (!anchor.symbol) {
     const lines = normalized.split("\n");
     if (lines.length > 1 && lines[lines.length - 1] === "") lines.pop();
     return {
-      text: normalized,
-      startLine: 1,
-      endLine: Math.max(1, lines.length)
+      ok: true,
+      span: {
+        text: normalized,
+        startLine: 1,
+        endLine: Math.max(1, lines.length)
+      }
+    };
+  }
+  for (const resolver of resolvers) {
+    const attempt = resolver.attempt ? resolver.attempt(normalized, anchor.symbol, anchor.file) : fromResolve(resolver, normalized, anchor.symbol, anchor.file);
+    if (attempt.kind === "abstain") continue;
+    if (attempt.kind === "unresolved") {
+      if (attempt.reason === "symbol-not-found") continue;
+      return { ok: false, reason: attempt.reason };
+    }
+    return {
+      ok: true,
+      span: attempt.span,
+      ...isResolverName(resolver.name) ? { resolver: resolver.name } : {}
     };
   }
-  return resolver.resolve(normalized, anchor.symbol);
+  return { ok: false, reason: "symbol-not-found" };
+}
+function fromResolve(resolver, source, symbol, file) {
+  const span2 = resolver.resolve(source, symbol, file);
+  return span2 ? { kind: "resolved", span: span2 } : { kind: "unresolved", reason: "symbol-not-found" };
+}
+function isResolverName(name) {
+  return name === "tree-sitter" || name === "regex";
+}
+async function prepareResolvers(resolvers, files) {
+  for (const resolver of resolvers) await resolver.prepare?.(files);
+}
+function defaultAnchorResolvers(grammars = {}) {
+  return [new TreeSitterResolver(grammars), regexResolver];
+}
+function resolverChanged(source, anchor, produced) {
+  const previous = anchor.resolver ?? "regex";
+  if (!produced || !anchor.symbol || previous === produced) return false;
+  if (previous !== "regex") return false;
+  const before = regexResolver.resolve(
+    source.replace(/\r\n/g, "\n"),
+    anchor.symbol
+  );
+  return before !== null && hashAnchorText(before.text) === anchor.hash;
 }
 
 // src/anchor-resolver/drift.ts
 async function detectAnchorDrift(records, options = {}) {
   const repoRoot = options.repoRoot ?? process.cwd();
-  const resolver = options.resolver ?? regexResolver;
+  const resolvers = options.resolvers ?? (options.resolver ? [options.resolver] : defaultAnchorResolvers({
+    offline: options.remote?.offline === true
+  }));
   const origin = new LazyOrigin(repoRoot);
   const planned = /* @__PURE__ */ new Map();
   let declaresRepo = false;
@@ -1212,12 +1777,16 @@ async function detectAnchorDrift(records, options = {}) {
     ),
     (options.readRemote ?? readRemoteAnchors)(wants, options.remote ?? {})
   ]);
+  await prepareResolvers(resolvers, [
+    ...files,
+    ...wants.map((want) => want.file)
+  ]);
   const drift = /* @__PURE__ */ new Map();
   for (const record of records) {
     const entries = [];
     for (const { anchor, foreign } of planned.get(record.conceptId) ?? []) {
       entries.push(
-        foreign ? remoteEntry(anchor, remote, resolver) : localEntry(anchor, reads.get(anchor.file), resolver)
+        foreign ? remoteEntry(anchor, remote, resolvers) : localEntry(anchor, reads.get(anchor.file), resolvers)
       );
     }
     if (entries.length) drift.set(record.conceptId, entries);
@@ -1246,12 +1815,22 @@ function unresolved(anchor, reason, repo) {
     ...repo ? { repo } : {}
   };
 }
-function hashIn(source, anchor, resolver) {
-  const resolved = resolveAnchor(source, anchor, resolver);
-  if (!resolved) return null;
+function hashIn(source, anchor, resolvers) {
+  const outcome = resolveAnchorSpan(source, anchor, resolvers);
+  if (!outcome.ok) return { ok: false, reason: outcome.reason };
+  return {
+    ok: true,
+    current: {
+      hash: hashAnchorText(outcome.span.text),
+      lines: outcome.span.endLine - outcome.span.startLine + 1,
+      ...outcome.resolver ? { resolver: outcome.resolver } : {}
+    }
+  };
+}
+function resolverExtras(source, anchor, current) {
   return {
-    hash: hashAnchorText(resolved.text),
-    lines: resolved.endLine - resolved.startLine + 1
+    ...current.resolver ? { resolver: current.resolver } : {},
+    ...current.hash !== anchor.hash && resolverChanged(source, anchor, current.resolver) ? { reason: "resolver-changed" } : {}
   };
 }
 function compared(anchor, current, extra = {}) {
@@ -1263,30 +1842,48 @@ function compared(anchor, current, extra = {}) {
     ...extra
   };
 }
-function localEntry(anchor, read, resolver) {
+function localEntry(anchor, read, resolvers) {
   if (!read.ok) return unresolved(anchor, read.reason);
-  const current = hashIn(read.source, anchor, resolver);
-  return current ? compared(anchor, current) : unresolved(anchor, "symbol-not-found");
+  const found = hashIn(read.source, anchor, resolvers);
+  if (!found.ok) return unresolved(anchor, found.reason);
+  return compared(
+    anchor,
+    found.current,
+    resolverExtras(read.source, anchor, found.current)
+  );
 }
-function remoteEntry(anchor, remote, resolver) {
+function remoteEntry(anchor, remote, resolvers) {
   const repo = anchor.repo;
   const key = normalizeRepoUrl(repo);
   const atDefault = remote.get(wantKey(key, void 0, anchor.file));
   const primary = anchor.ref ? remote.get(wantKey(key, anchor.ref, anchor.file)) : atDefault;
   if (!primary) return unresolved(anchor, "remote-unreachable", repo);
   if (!primary.ok) return unresolved(anchor, primary.reason, repo);
-  const current = hashIn(primary.source, anchor, resolver);
-  if (!current) return unresolved(anchor, "symbol-not-found", repo);
-  if (!anchor.ref) return compared(anchor, current, { repo });
+  const found = hashIn(primary.source, anchor, resolvers);
+  if (!found.ok) return unresolved(anchor, found.reason, repo);
+  const current = found.current;
+  const extras = resolverExtras(primary.source, anchor, current);
+  if (!anchor.ref) return compared(anchor, current, { repo, ...extras });
   if (current.hash !== anchor.hash) {
-    return compared(anchor, current, { repo, remoteState: "drifted-from-ref" });
+    return compared(anchor, current, {
+      repo,
+      ...extras,
+      remoteState: "drifted-from-ref"
+    });
   }
-  const head = atDefault?.ok ? hashIn(atDefault.source, anchor, resolver) : null;
-  return head && head.hash !== anchor.hash ? {
-    ...compared(anchor, head, { repo }),
+  const head = atDefault?.ok ? hashIn(atDefault.source, anchor, resolvers) : null;
+  return head?.ok && head.current.hash !== anchor.hash ? {
+    ...compared(anchor, head.current, {
+      repo,
+      ...head.current.resolver ? { resolver: head.current.resolver } : {}
+    }),
     state: "drifted",
     remoteState: "drifted-on-default"
-  } : compared(anchor, current, { repo, remoteState: "matches-ref" });
+  } : compared(anchor, current, {
+    repo,
+    ...extras,
+    remoteState: "matches-ref"
+  });
 }
 
 // src/errors.ts
@@ -1440,13 +2037,43 @@ var KbInvalidConceptIdError = class extends BaseError {
     });
   }
 };
+var KbStampBaselineError = class extends BaseError {
+  constructor(since) {
+    super({
+      message: `kb: --since ${since} is neither a 64-character digest nor a readable stamp file`,
+      errorType: "KbStampBaselineUnreadable" /* KbStampBaselineUnreadable */,
+      code: 400,
+      fault: "User" /* User */,
+      retriable: false,
+      reportToUser: true,
+      details: { since }
+    });
+    this.since = since;
+  }
+  since;
+};
+var KbStampDigestBaselineError = class extends BaseError {
+  constructor(since) {
+    super({
+      message: `kb: --since ${since} is a digest, which needs --bundle (one base) \u2014 a file baseline works for many`,
+      errorType: "KbStampDigestBaselineAmbiguous" /* KbStampDigestBaselineAmbiguous */,
+      code: 400,
+      fault: "User" /* User */,
+      retriable: false,
+      reportToUser: true,
+      details: { since }
+    });
+    this.since = since;
+  }
+  since;
+};
 
 // src/kb-pins/budgets.ts
 function asBudgets(value) {
   if (value === null || typeof value !== "object") return {};
-  const table = value;
+  const table2 = value;
   const pick = (key, min) => {
-    const raw = table[key];
+    const raw = table2[key];
     return typeof raw === "number" && Number.isInteger(raw) && raw >= min ? raw : void 0;
   };
   const budgetTokens = pick("budgetTokens", 1);
@@ -1457,9 +2084,9 @@ function asBudgets(value) {
   };
 }
 function contextProfileBudgets(manifest, profile) {
-  const table = manifest.context;
-  if (table === null || typeof table !== "object") return {};
-  const entries = table;
+  const table2 = manifest.context;
+  if (table2 === null || typeof table2 !== "object") return {};
+  const entries = table2;
   return {
     ...asBudgets(entries["default"]),
     ...profile ? asBudgets(entries[profile]) : {}
@@ -1490,23 +2117,23 @@ var KbBaseFrozenError = class extends Error {
 };
 
 // src/kb-pins/frozen.ts
-var import_node_path5 = require("path");
+var import_node_path8 = require("path");
 
 // src/kb-pins/layers.ts
-var import_promises3 = require("fs/promises");
-var import_node_os2 = require("os");
-var import_node_path4 = require("path");
+var import_promises5 = require("fs/promises");
+var import_node_os3 = require("os");
+var import_node_path7 = require("path");
 
 // src/kb-pins/model.ts
-var import_node_path3 = require("path");
-var import_zod4 = require("zod");
-var PINS_FILE = (0, import_node_path3.join)(".strauss", "kb-pins.json");
-var PINS_LOCAL_FILE = (0, import_node_path3.join)(".strauss", "kb-pins.local.json");
+var import_node_path6 = require("path");
+var import_zod5 = require("zod");
+var PINS_FILE = (0, import_node_path6.join)(".strauss", "kb-pins.json");
+var PINS_LOCAL_FILE = (0, import_node_path6.join)(".strauss", "kb-pins.local.json");
 var PIN_LAYERS = ["project", "local", "user"];
-var pinSchema = import_zod4.z.object({
+var pinSchema = import_zod5.z.object({
   /** Relative to the manifest's root, so the file is committable. */
-  path: import_zod4.z.string().min(1),
-  pinnedAt: import_zod4.z.string().min(1).optional(),
+  path: import_zod5.z.string().min(1),
+  pinnedAt: import_zod5.z.string().min(1).optional(),
   /**
    * How `context` renders this base. `full` preloads the whole base into
    * the block regardless of the full-under threshold — for a base whose
@@ -1516,7 +2143,7 @@ var pinSchema = import_zod4.z.object({
    * Absent: the profile's full-under threshold decides. Invalid values
    * degrade to absent rather than failing the manifest.
    */
-  mode: import_zod4.z.enum(["full", "index"]).optional().catch(void 0),
+  mode: import_zod5.z.enum(["full", "index"]).optional().catch(void 0),
   /**
    * Context profiles this pin surfaces in (e.g. only at session-start,
    * not per turn). Absent: every profile. A run without a profile sees
@@ -1524,17 +2151,17 @@ var pinSchema = import_zod4.z.object({
    * that skill at point of use than pinned at all — pins are what every
    * session should see.
    */
-  profiles: import_zod4.z.array(import_zod4.z.string()).optional().catch(void 0),
+  profiles: import_zod5.z.array(import_zod5.z.string()).optional().catch(void 0),
   /**
    * The base is concluded — a finished piece of research, a frozen ADR
    * set. Write commands against it refuse while this workspace holds the
    * pin, and `context` labels it read-only. Workspace policy, not base
    * state: the base itself stays copyable and writable elsewhere.
    */
-  frozen: import_zod4.z.boolean().optional().catch(void 0)
+  frozen: import_zod5.z.boolean().optional().catch(void 0)
 }).passthrough();
-var pinsManifestSchema = import_zod4.z.object({
-  pins: import_zod4.z.array(pinSchema).default([]),
+var pinsManifestSchema = import_zod5.z.object({
+  pins: import_zod5.z.array(pinSchema).default([]),
   /**
    * Per-repo budgets for the `context` command, keyed by profile —
    * `"session-start"`, `"compact"`, `"turn"`, or `"default"` for all of
@@ -1543,18 +2170,18 @@ var pinsManifestSchema = import_zod4.z.object({
    * the index at every session start. `contextProfileBudgets` does the
    * tolerant read.
    */
-  context: import_zod4.z.unknown().optional()
+  context: import_zod5.z.unknown().optional()
 }).passthrough();
 
 // src/kb-pins/layers.ts
 function userRoot() {
-  return process.env.STRAUSS_KB_USER_ROOT || (0, import_node_os2.homedir)();
+  return process.env.STRAUSS_KB_USER_ROOT || (0, import_node_os3.homedir)();
 }
 function layerRoot(workspaceDir, layer) {
-  return layer === "user" ? userRoot() : (0, import_node_path4.resolve)(workspaceDir);
+  return layer === "user" ? userRoot() : (0, import_node_path7.resolve)(workspaceDir);
 }
 function layerFile(workspaceDir, layer) {
-  return (0, import_node_path4.join)(
+  return (0, import_node_path7.join)(
     layerRoot(workspaceDir, layer),
     layer === "local" ? PINS_LOCAL_FILE : PINS_FILE
   );
@@ -1563,7 +2190,7 @@ async function readPinsLayer(workspaceDir, layer) {
   const file = layerFile(workspaceDir, layer);
   let raw;
   try {
-    raw = await (0, import_promises3.readFile)(file, "utf8");
+    raw = await (0, import_promises5.readFile)(file, "utf8");
   } catch {
     return { pins: [] };
   }
@@ -1587,16 +2214,16 @@ async function readPinsLayer(workspaceDir, layer) {
 }
 async function writePinsLayer(workspaceDir, layer, manifest) {
   const file = layerFile(workspaceDir, layer);
-  await (0, import_promises3.mkdir)((0, import_node_path4.dirname)(file), { recursive: true });
-  await (0, import_promises3.writeFile)(file, `${JSON.stringify(manifest, null, 2)}
+  await (0, import_promises5.mkdir)((0, import_node_path7.dirname)(file), { recursive: true });
+  await (0, import_promises5.writeFile)(file, `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
 }
 function resolvePinPath(rootDir, path) {
-  return (0, import_node_path4.isAbsolute)(path) ? (0, import_node_path4.resolve)(path) : (0, import_node_path4.resolve)(rootDir, path.split("/").join(import_node_path4.sep));
+  return (0, import_node_path7.isAbsolute)(path) ? (0, import_node_path7.resolve)(path) : (0, import_node_path7.resolve)(rootDir, path.split("/").join(import_node_path7.sep));
 }
 function storablePath(rootDir, bundlePath2) {
-  const rel = (0, import_node_path4.relative)((0, import_node_path4.resolve)(rootDir), (0, import_node_path4.resolve)(bundlePath2));
-  return (rel === "" ? "." : rel).split(import_node_path4.sep).join("/");
+  const rel = (0, import_node_path7.relative)((0, import_node_path7.resolve)(rootDir), (0, import_node_path7.resolve)(bundlePath2));
+  return (rel === "" ? "." : rel).split(import_node_path7.sep).join("/");
 }
 async function readMergedPins(workspaceDir) {
   const manifests = {};
@@ -1624,7 +2251,7 @@ async function readMergedPins(workspaceDir) {
 // src/kb-pins/frozen.ts
 async function assertBaseNotFrozen(workspaceDir, bundlePath2) {
   const merged = await readMergedPins(workspaceDir);
-  const absolute = (0, import_node_path5.resolve)(bundlePath2);
+  const absolute = (0, import_node_path8.resolve)(bundlePath2);
   const pin = merged.pins.find((entry) => entry.absolutePath === absolute);
   if (pin?.frozen === true) {
     throw new KbBaseFrozenError(pin.path, pin.layer);
@@ -1709,7 +2336,7 @@ async function pinBase(store, workspaceDir, bundlePath2, at, options = {}) {
 }
 
 // src/kb-pins/unpin.ts
-var import_node_path6 = require("path");
+var import_node_path9 = require("path");
 async function unpinBase(workspaceDir, bundlePath2) {
   const layers = [];
   for (const layer of PIN_LAYERS) {
@@ -1730,17 +2357,17 @@ async function unpinBase(workspaceDir, bundlePath2) {
     }
   }
   return {
-    path: storablePath((0, import_node_path6.resolve)(workspaceDir), bundlePath2),
+    path: storablePath((0, import_node_path9.resolve)(workspaceDir), bundlePath2),
     removed: layers.length > 0,
     layers
   };
 }
 
 // src/commands/model.ts
-var import_zod5 = require("zod");
-var bundlePath = import_zod5.z.string().min(1).describe("Absolute path to the knowledge base directory.");
-var conceptId = import_zod5.z.string().min(1).describe("e.g. decision.cursor-v2");
-var REPO_ROOT = import_zod5.z.string().min(1).optional().describe(
+var import_zod6 = require("zod");
+var bundlePath = import_zod6.z.string().min(1).describe("Absolute path to the knowledge base directory.");
+var conceptId = import_zod6.z.string().min(1).describe("e.g. decision.cursor-v2");
+var REPO_ROOT = import_zod6.z.string().min(1).optional().describe(
   "Where the anchored source lives, for the drift check. Defaults to the working directory."
 );
 function define(command) {
@@ -1763,22 +2390,30 @@ function argvFlag(argv, name) {
 }
 
 // src/commands/anchor-resolve.ts
+function resolverSummary(results) {
+  const names = [
+    ...new Set(
+      results.flatMap((entry) => entry.resolver ? [entry.resolver] : [])
+    )
+  ].sort();
+  return names.length ? `${names.join(" + ")} resolver` : "whole-file";
+}
 var anchorResolveCommand = define({
   name: "anchor-resolve",
   tool: "kb_anchor_resolve",
   usage: "anchor-resolve <concept-id> [--repo-root <path>] [--offline] [--rebaseline] [--restamp]",
   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. kb_verify's mechanical counterpart \u2014 reach for it when the question is whether the code still is what it was. Exits non-zero on drift.",
-  input: import_zod6.z.object({
+  input: import_zod7.z.object({
     bundlePath,
     conceptId,
-    repoRoot: import_zod6.z.string().min(1).optional(),
-    offline: import_zod6.z.boolean().optional().describe(
+    repoRoot: import_zod7.z.string().min(1).optional(),
+    offline: import_zod7.z.boolean().optional().describe(
       "Resolve foreign anchors from the local repo cache only, never fetching."
     ),
-    rebaseline: import_zod6.z.boolean().optional().describe(
+    rebaseline: import_zod7.z.boolean().optional().describe(
       "Accept the current code as the new baseline for anchors that drifted."
     ),
-    restamp: import_zod6.z.boolean().optional().describe(
+    restamp: import_zod7.z.boolean().optional().describe(
       "Refresh `resolved_at` on anchors that already match. Off by default, so a green run writes nothing."
     )
   }),
@@ -1807,6 +2442,11 @@ var anchorResolveCommand = define({
     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,
@@ -1823,27 +2463,35 @@ var anchorResolveCommand = define({
         updated.push(anchor);
         continue;
       }
-      const resolved = resolveAnchor(source.source, anchor);
-      if (!resolved) {
+      const outcome = resolveAnchorSpan(source.source, anchor, resolvers);
+      if (!outcome.ok) {
         results.push({
           ...base2,
           state: "unresolved",
-          reason: "symbol-not-found"
+          reason: outcome.reason
         });
         updated.push(anchor);
         continue;
       }
+      const resolved = outcome.span;
+      const producedBy = outcome.resolver;
       const currentHash = hashAnchorText(resolved.text);
       const currentLines = resolved.endLine - resolved.startLine + 1;
       const stamped = {
         ...anchor,
         hash: currentHash,
         lines: currentLines,
-        resolved_at: now()
+        resolved_at: now(),
+        ...producedBy ? { resolver: producedBy } : {}
       };
       const pinned = anchor.ref !== void 0 && source.repo !== void 0;
       if (!anchor.hash) {
-        results.push({ ...base2, state: "stamped", currentHash });
+        results.push({
+          ...base2,
+          state: "stamped",
+          currentHash,
+          ...producedBy ? { resolver: producedBy } : {}
+        });
         updated.push(stamped);
         dirty = true;
         continue;
@@ -1854,6 +2502,10 @@ var anchorResolveCommand = define({
           state: "drifted",
           currentHash,
           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 } : {}
         });
@@ -1861,7 +2513,7 @@ var anchorResolveCommand = define({
         if (rebaseline) dirty = true;
         continue;
       }
-      const onDefault = pinned ? headHash(source, anchor) : void 0;
+      const onDefault = pinned ? headHash(source, anchor, resolvers) : void 0;
       if (onDefault && onDefault.hash !== anchor.hash) {
         results.push({
           ...base2,
@@ -1877,6 +2529,7 @@ var anchorResolveCommand = define({
         ...base2,
         state: "match",
         currentHash,
+        ...producedBy ? { resolver: producedBy } : {},
         ...pinned ? { remoteState: "matches-ref" } : {}
       });
       const refresh = restamp || anchor.resolved_at === void 0;
@@ -1894,19 +2547,21 @@ var anchorResolveCommand = define({
       if (!frozen) await store.updateAnchors(path, id, updated, actor);
     }
     const frozenNote = frozen ? { frozen: true, note: "base is frozen: nothing was stamped" } : {};
+    const hints = grammarHints();
+    const hintNote = hints.length ? { hints } : {};
     const unreachable = results.filter(
       (entry) => isUncheckedReason(entry.reason)
     ).length;
     const checked = results.length - unreachable;
-    const matches2 = results.filter((entry) => entry.state === "match").length;
-    const note = `${matches2}/${checked} anchors match${unreachable ? `, ${unreachable} unreachable` : ""}`;
-    const clean = checked > 0 && matches2 === checked && unreachable === 0;
+    const matches3 = results.filter((entry) => entry.state === "match").length;
+    const note = `${matches3}/${checked} anchors match${unreachable ? `, ${unreachable} unreachable` : ""}`;
+    const clean = checked > 0 && matches3 === checked && unreachable === 0;
     if (clean) {
       try {
         await store.verify(
           path,
           id,
-          `anchor-resolve: ${note} (regex resolver)`,
+          `anchor-resolve: ${note} (${resolverSummary(results)})`,
           actor,
           now()
         );
@@ -1917,17 +2572,25 @@ var anchorResolveCommand = define({
           results,
           verified: false,
           verifyRefused: "self-verification",
-          ...frozenNote
+          ...frozenNote,
+          ...hintNote
         };
       }
-      return { conceptId: id, results, verified: true, ...frozenNote };
+      return {
+        conceptId: id,
+        results,
+        verified: true,
+        ...frozenNote,
+        ...hintNote
+      };
     }
     return {
       conceptId: id,
       results,
       verified: false,
       ...unreachable ? { note } : {},
-      ...frozenNote
+      ...frozenNote,
+      ...hintNote
     };
   },
   // A stored hash that no longer resolves is a broken anchor, not an absence:
@@ -1943,13 +2606,13 @@ var anchorResolveCommand = define({
 function lineDelta(anchor, current) {
   return anchor.lines === void 0 ? null : Math.abs(current - anchor.lines);
 }
-function headHash(source, anchor) {
+function headHash(source, anchor, resolvers) {
   if (source.head === void 0) return void 0;
-  const resolved = resolveAnchor(source.head, anchor);
-  if (!resolved) return void 0;
+  const outcome = resolveAnchorSpan(source.head, anchor, resolvers);
+  if (!outcome.ok) return void 0;
   return {
-    hash: hashAnchorText(resolved.text),
-    lines: resolved.endLine - resolved.startLine + 1
+    hash: hashAnchorText(outcome.span.text),
+    lines: outcome.span.endLine - outcome.span.startLine + 1
   };
 }
 async function readSources(anchors, root, offline) {
@@ -1999,13 +2662,13 @@ async function readSources(anchors, root, offline) {
 }
 
 // src/commands/answer.ts
-var import_zod7 = require("zod");
+var import_zod8 = require("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: import_zod7.z.object({ bundlePath, conceptId, answer: import_zod7.z.string().min(1) }),
+  input: import_zod8.z.object({ bundlePath, conceptId, answer: import_zod8.z.string().min(1) }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
     conceptId: argv[1],
@@ -2019,19 +2682,19 @@ var answerCommand = define({
 });
 
 // src/commands/backlinks.ts
-var import_zod8 = require("zod");
+var import_zod9 = require("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: import_zod8.z.object({ bundlePath, conceptId }),
+  input: import_zod9.z.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
-var import_zod9 = require("zod");
+var import_zod10 = require("zod");
 
 // src/adjudicate.ts
 var STANDING = {
@@ -2109,8 +2772,8 @@ function resolveHeads(from, byId) {
   while (queue.length) {
     const current = queue.shift();
     const next = successors(current, byId);
-    for (const missing of next.missing) {
-      warnings.push({ kind: "broken-chain", missing });
+    for (const missing2 of next.missing) {
+      warnings.push({ kind: "broken-chain", missing: missing2 });
     }
     if (!next.records.length) {
       if (current.conceptId !== from.conceptId)
@@ -2141,13 +2804,13 @@ function successors(record, byId) {
     }
   }
   const records = [];
-  const missing = [];
+  const missing2 = [];
   for (const id of ids) {
     const found = byId.get(id);
     if (found) records.push(found);
-    else missing.push(id);
+    else missing2.push(id);
   }
-  return { records, missing };
+  return { records, missing: missing2 };
 }
 
 // src/catalog.ts
@@ -2202,9 +2865,9 @@ var catalogCommand = define({
   tool: "kb_catalog",
   usage: "catalog [type]",
   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: import_zod9.z.object({
+  input: import_zod10.z.object({
     bundlePath,
-    type: import_zod9.z.enum(KB_RECORD_TYPES).optional()
+    type: import_zod10.z.enum(KB_RECORD_TYPES).optional()
   }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
@@ -2259,10 +2922,10 @@ function count(value, noun) {
 }
 
 // src/commands/context.ts
-var import_zod10 = require("zod");
+var import_zod11 = require("zod");
 
 // src/kb-context.ts
-var import_promises4 = require("fs/promises");
+var import_promises6 = require("fs/promises");
 
 // src/kb-index.ts
 var INDEX_FILE = "INDEX.md";
@@ -2489,13 +3152,13 @@ function toHookJson(block, event) {
 var CONTEXT_BEGIN = "<!-- strauss-kb:begin -->";
 var CONTEXT_END = "<!-- strauss-kb:end -->";
 async function syncInstructions(file, block) {
-  const existing = await (0, import_promises4.readFile)(file, "utf8").catch(() => null);
+  const existing = await (0, import_promises6.readFile)(file, "utf8").catch(() => null);
   const region = block ? `${CONTEXT_BEGIN}
 ${block.trim()}
 ${CONTEXT_END}` : null;
   if (existing === null) {
     if (!region) return { file, action: "unchanged" };
-    await (0, import_promises4.writeFile)(file, `${region}
+    await (0, import_promises6.writeFile)(file, `${region}
 `, "utf8");
     return { file, action: "created" };
   }
@@ -2506,11 +3169,11 @@ ${CONTEXT_END}` : null;
     const after = existing.slice(end + CONTEXT_END.length);
     const next = region ? `${before}${region}${after}` : `${before.replace(/\n+$/, "\n")}${after.replace(/^\n+/, "\n")}`;
     if (next === existing) return { file, action: "unchanged" };
-    await (0, import_promises4.writeFile)(file, next, "utf8");
+    await (0, import_promises6.writeFile)(file, next, "utf8");
     return { file, action: region ? "replaced" : "removed" };
   }
   if (!region) return { file, action: "unchanged" };
-  await (0, import_promises4.writeFile)(
+  await (0, import_promises6.writeFile)(
     file,
     `${existing.replace(/\n*$/, "\n\n")}${region}
 `,
@@ -2525,20 +3188,20 @@ var contextCommand = define({
   tool: "kb_context",
   usage: "context [--profile NAME] [--budget N] [--full-under N] [--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: import_zod10.z.object({
-    budgetTokens: import_zod10.z.number().int().positive().optional().describe(
+  input: import_zod11.z.object({
+    budgetTokens: import_zod11.z.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: import_zod10.z.number().int().positive().optional().describe(
+    fullUnderTokens: import_zod11.z.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: import_zod10.z.string().optional().describe(
+    profile: import_zod11.z.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."
     ),
-    format: import_zod10.z.enum(["markdown", "json"]).optional().describe(
+    format: import_zod11.z.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: import_zod10.z.string().optional().describe(
+    event: import_zod11.z.string().optional().describe(
       "hookEventName stamped into the JSON envelope. Only meaningful with format=json."
     )
   }),
@@ -2574,7 +3237,7 @@ var contextCommand = define({
 });
 
 // src/commands/doctor.ts
-var import_zod11 = require("zod");
+var import_zod12 = require("zod");
 
 // src/kb-edges.ts
 var KB_EDGE_KINDS = [
@@ -2760,6 +3423,18 @@ var CHECK_HEADLINES = {
   unchecked: "an anchor in another repository nothing could reach"
 };
 var DAY_MS = 864e5;
+function anchorResolverCounts(bundle) {
+  let treeSitter = 0;
+  let regex = 0;
+  for (const record of bundle) {
+    for (const anchor of record.frontmatter.strauss_anchors ?? []) {
+      if (!anchor.hash || !anchor.symbol) continue;
+      if (anchor.resolver === "tree-sitter") treeSitter += 1;
+      else regex += 1;
+    }
+  }
+  return { total: treeSitter + regex, treeSitter, regex };
+}
 function doctor(bundle, options = {}) {
   const thresholds = {
     expiringDays: options.expiringDays ?? DEFAULT_EXPIRING_DAYS,
@@ -2795,6 +3470,7 @@ function doctor(bundle, options = {}) {
     counts,
     groups,
     findingCount,
+    anchorResolvers: anchorResolverCounts(bundle),
     healthy: findingCount === 0
   };
 }
@@ -3041,13 +3717,13 @@ function ageInDays(record, now) {
 }
 
 // src/commands/doctor.ts
-var days = (what, fallback) => import_zod11.z.number().int().positive().optional().describe(`${what} Defaults to ${fallback}.`);
+var days = (what, fallback) => import_zod12.z.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]",
   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. Use it when picking up a base you have not touched in a while; kb_validate only checks that pointers between records agree.",
-  input: import_zod11.z.object({
+  input: import_zod12.z.object({
     bundlePath,
     repoRoot: REPO_ROOT,
     expiringDays: days(
@@ -3062,10 +3738,10 @@ var doctorCommand = define({
       "How long a record may stay `open` or `proposed` before `aging` reports it, in days.",
       DEFAULT_AGING_DAYS
     ),
-    offline: import_zod11.z.boolean().optional().describe(
+    offline: import_zod12.z.boolean().optional().describe(
       "Read foreign anchors from the local repo cache only, never fetching."
     ),
-    strict: import_zod11.z.boolean().optional().describe(
+    strict: import_zod12.z.boolean().optional().describe(
       "Turn an expired record into a non-zero exit for the CLI. No effect on the report itself."
     )
   }),
@@ -3108,7 +3784,13 @@ var doctorCommand = define({
       ...anchorDrift !== void 0 ? { anchorDrift } : {},
       now: new Date(checkedAt)
     });
-    return { bundlePath: path, checkedAt, ...report };
+    const hints = grammarHints();
+    return {
+      bundlePath: path,
+      checkedAt,
+      ...report,
+      ...hints.length ? { hints } : {}
+    };
   },
   render: (result) => render2(result),
   // Only expiry, and only under --strict. The other seven checks report debt a
@@ -3126,12 +3808,15 @@ function render2(result) {
     `records: ${result.recordCount}`,
     `thresholds: expiring within ${thresholds.expiringDays}d, unverified over ${thresholds.unverifiedDays}d, aging over ${thresholds.agingDays}d`,
     `checked: ${result.checkedAt}`,
+    ...result.anchorResolvers.total ? [
+      `anchors: ${result.anchorResolvers.total} hashed \u2014 ${result.anchorResolvers.treeSitter} tree-sitter, ${result.anchorResolvers.regex} regex`
+    ] : [],
     ""
   ];
-  const width = Math.max(...result.groups.map((group2) => group2.check.length));
+  const width2 = Math.max(...result.groups.map((group2) => group2.check.length));
   for (const group2 of result.groups) {
     lines.push(
-      `  ${group2.check.padEnd(width)}  ${String(group2.count).padStart(3)}  ${group2.headline}`
+      `  ${group2.check.padEnd(width2)}  ${String(group2.count).padStart(3)}  ${group2.headline}`
     );
   }
   for (const group2 of result.groups) {
@@ -3143,6 +3828,7 @@ function render2(result) {
       );
     }
   }
+  for (const hint of result.hints ?? []) lines.push("", hint);
   lines.push(
     "",
     result.healthy ? "Nothing to repair." : `${result.findingCount} finding${result.findingCount === 1 ? "" : "s"} across ${result.groups.filter((group2) => group2.count).length} of ${result.groups.length} checks.`
@@ -3151,19 +3837,19 @@ function render2(result) {
 }
 
 // src/commands/impact.ts
-var import_zod12 = require("zod");
+var import_zod13 = require("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: import_zod12.z.object({
+  input: import_zod13.z.object({
     bundlePath,
     conceptId,
-    depth: import_zod12.z.number().int().positive().optional().describe(
+    depth: import_zod13.z.number().int().positive().optional().describe(
       "Hops out from the record. Unbounded when omitted; a walk this cuts reports truncated: true."
     ),
-    rels: import_zod12.z.array(import_zod12.z.enum(KB_CAUSAL_LINK_RELS)).optional().describe(
+    rels: import_zod13.z.array(import_zod13.z.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."
     )
   }),
@@ -3184,13 +3870,13 @@ var impactCommand = define({
 });
 
 // src/commands/list.ts
-var import_zod13 = require("zod");
+var import_zod14 = require("zod");
 var listCommand = define({
   name: "list",
   tool: "kb_list",
   usage: "list [type]",
   description: "Every record, optionally one type. For enumerating; use kb_query for a question.",
-  input: import_zod13.z.object({ bundlePath, type: import_zod13.z.enum(KB_RECORD_TYPES).optional() }),
+  input: import_zod14.z.object({ bundlePath, type: import_zod14.z.enum(KB_RECORD_TYPES).optional() }),
   fromArgv: (argv, path) => ({ bundlePath: path, type: argv[1] }),
   run: async ({ store }, { bundlePath: path, type }) => (await store.list(path, type)).map((record) => ({
     conceptId: record.conceptId,
@@ -3202,17 +3888,17 @@ var listCommand = define({
 });
 
 // src/commands/load.ts
-var import_zod14 = require("zod");
+var import_zod15 = require("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: import_zod14.z.object({
+  input: import_zod15.z.object({
     bundlePath,
-    type: import_zod14.z.enum(KB_RECORD_TYPES).optional(),
-    budgetTokens: import_zod14.z.number().int().positive().optional().describe("Approximate token ceiling. Defaults to 25000."),
-    all: import_zod14.z.boolean().optional().describe(
+    type: import_zod15.z.enum(KB_RECORD_TYPES).optional(),
+    budgetTokens: import_zod15.z.number().int().positive().optional().describe("Approximate token ceiling. Defaults to 25000."),
+    all: import_zod15.z.boolean().optional().describe(
       "Loads the entire base regardless of size, bypassing the token budget; mutually exclusive with budgetTokens."
     ),
     repoRoot: REPO_ROOT
@@ -3254,25 +3940,25 @@ var loadCommand = define({
 });
 
 // src/commands/log.ts
-var import_zod15 = require("zod");
+var import_zod16 = require("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: import_zod15.z.object({ bundlePath }),
+  input: import_zod16.z.object({ bundlePath }),
   fromArgv: (_argv, path) => ({ bundlePath: path }),
   run: ({ store }, { bundlePath: path }) => store.readLog(path)
 });
 
 // src/commands/no-decision.ts
-var import_zod16 = require("zod");
+var import_zod17 = require("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: import_zod16.z.object({ bundlePath, reason: import_zod16.z.string().min(1) }),
+  input: import_zod17.z.object({ bundlePath, reason: import_zod17.z.string().min(1) }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
     reason: argv.slice(1).join(" ").trim()
@@ -3289,20 +3975,20 @@ var noDecisionCommand = define({
 });
 
 // src/commands/pack.ts
-var import_zod17 = require("zod");
+var import_zod18 = require("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: import_zod17.z.object({
+  input: import_zod18.z.object({
     bundlePath,
     conceptId,
-    hops: import_zod17.z.number().int().positive().optional().describe("How far from the root the walk may reach. Defaults to 2."),
-    maxNodes: import_zod17.z.number().int().positive().optional().describe(
+    hops: import_zod18.z.number().int().positive().optional().describe("How far from the root the walk may reach. Defaults to 2."),
+    maxNodes: import_zod18.z.number().int().positive().optional().describe(
       "How many records the pack may hold, root included. Defaults to 20."
     ),
-    budgetTokens: import_zod17.z.number().int().positive().optional().describe(
+    budgetTokens: import_zod18.z.number().int().positive().optional().describe(
       "Approximate token ceiling over what is actually emitted. Defaults to 25000."
     )
   }),
@@ -3389,22 +4075,22 @@ function warningLabel(warning) {
 }
 
 // src/commands/pin.ts
-var import_zod18 = require("zod");
+var import_zod19 = require("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: import_zod18.z.object({
+  input: import_zod19.z.object({
     bundlePath,
-    mode: import_zod18.z.enum(["full", "index"]).optional().describe(
+    mode: import_zod19.z.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: import_zod18.z.array(import_zod18.z.string()).optional().describe("Context profiles this pin surfaces in. Absent: all of them."),
-    layer: import_zod18.z.enum(["project", "local", "user"]).optional().describe(
+    profiles: import_zod19.z.array(import_zod19.z.string()).optional().describe("Context profiles this pin surfaces in. Absent: all of them."),
+    layer: import_zod19.z.enum(["project", "local", "user"]).optional().describe(
       "Which manifest to write: project (committed, default), local (personal, gitignored), user (~/.strauss, every workspace)."
     ),
-    frozen: import_zod18.z.boolean().optional().describe(
+    frozen: import_zod19.z.boolean().optional().describe(
       "true: the base is concluded \u2014 writes against it refuse while pinned. false: lift a freeze."
     )
   }),
@@ -3433,29 +4119,29 @@ var pinCommand = define({
 });
 
 // src/commands/pins.ts
-var import_zod19 = require("zod");
+var import_zod20 = require("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: import_zod19.z.object({}),
+  input: import_zod20.z.object({}),
   fromArgv: () => ({}),
   run: ({ store }) => listPins(store, process.cwd())
 });
 
 // src/commands/query.ts
-var import_zod20 = require("zod");
+var import_zod21 = require("zod");
 var queryCommand = define({
   name: "query",
   tool: "kb_query",
   usage: "query <text...> [--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: import_zod20.z.object({
+  input: import_zod21.z.object({
     bundlePath,
-    text: import_zod20.z.string().optional(),
-    type: import_zod20.z.enum(KB_RECORD_TYPES).optional(),
-    includeNonCurrent: import_zod20.z.boolean().optional(),
+    text: import_zod21.z.string().optional(),
+    type: import_zod21.z.enum(KB_RECORD_TYPES).optional(),
+    includeNonCurrent: import_zod21.z.boolean().optional(),
     repoRoot: REPO_ROOT
   }),
   // `--repo-root` is a flag, so its value must not fall into the search text.
@@ -3487,27 +4173,27 @@ var queryCommand = define({
 });
 
 // src/commands/read-index.ts
-var import_zod21 = require("zod");
+var import_zod22 = require("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: import_zod21.z.object({ bundlePath }),
+  input: import_zod22.z.object({ bundlePath }),
   fromArgv: (_argv, path) => ({ bundlePath: path }),
   run: ({ store }, { bundlePath: path }) => store.readIndex(path)
 });
 
 // src/commands/schema.ts
-var import_zod24 = require("zod");
+var import_zod25 = require("zod");
 
 // src/json-schema.ts
-var import_zod23 = require("zod");
+var import_zod24 = require("zod");
 
 // src/kb-log.ts
-var import_zod22 = require("zod");
+var import_zod23 = require("zod");
 var LOG_FILE = "log.jsonl";
-var kbLogEntrySchema = import_zod22.z.object({
+var kbLogEntrySchema = import_zod23.z.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
@@ -3516,12 +4202,12 @@ var kbLogEntrySchema = import_zod22.z.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: import_zod22.z.iso.datetime(),
-  by: import_zod22.z.string().min(1),
-  operation: import_zod22.z.string().min(1),
-  conceptId: import_zod22.z.string().min(1),
+  at: import_zod23.z.iso.datetime(),
+  by: import_zod23.z.string().min(1),
+  operation: import_zod23.z.string().min(1),
+  conceptId: import_zod23.z.string().min(1),
   /** Second concept id, where the operation relates two — supersession. */
-  target: import_zod22.z.string().min(1).optional()
+  target: import_zod23.z.string().min(1).optional()
 }).strict();
 function renderLogEntry(entry) {
   return `${JSON.stringify(kbLogEntrySchema.parse(entry))}
@@ -3531,18 +4217,18 @@ function parseLog(raw) {
   const entries = [];
   const malformed = [];
   const seen = /* @__PURE__ */ new Set();
-  raw.split("\n").forEach((text, index) => {
+  raw.split("\n").forEach((text, index2) => {
     if (!text.trim()) return;
     let value;
     try {
       value = JSON.parse(text);
     } catch {
-      malformed.push({ line: index + 1, text });
+      malformed.push({ line: index2 + 1, text });
       return;
     }
     const parsed = kbLogEntrySchema.safeParse(value);
     if (!parsed.success) {
-      malformed.push({ line: index + 1, text });
+      malformed.push({ line: index2 + 1, text });
       return;
     }
     const key = JSON.stringify(parsed.data);
@@ -3559,11 +4245,11 @@ function parseLog(raw) {
 // src/json-schema.ts
 function kbJsonSchemas() {
   return {
-    recordFrontmatter: import_zod23.z.toJSONSchema(kbRecordFrontmatterSchema, {
+    recordFrontmatter: import_zod24.z.toJSONSchema(kbRecordFrontmatterSchema, {
       io: "input"
     }),
-    composeInput: import_zod23.z.toJSONSchema(composeInputSchema, { io: "input" }),
-    logEntry: import_zod23.z.toJSONSchema(kbLogEntrySchema, { io: "input" })
+    composeInput: import_zod24.z.toJSONSchema(composeInputSchema, { io: "input" }),
+    logEntry: import_zod24.z.toJSONSchema(kbLogEntrySchema, { io: "input" })
   };
 }
 
@@ -3573,22 +4259,120 @@ var schemaCommand = define({
   tool: "kb_schema",
   usage: "schema",
   description: "JSON Schema for frontmatter, write input, and log entries, generated from the enforcing code.",
-  input: import_zod24.z.object({}),
+  input: import_zod25.z.object({}),
   fromArgv: () => ({}),
   run: () => Promise.resolve(kbJsonSchemas())
 });
 
+// src/commands/stamp.ts
+var import_promises7 = require("fs/promises");
+var import_zod26 = require("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 \u2014 without any bodies. Takes no bundlePath to stamp every pinned base. With `since`, reports only the bases that moved, naming the changed ids when the baseline is a prior stamp; silent when nothing changed. Reads, never writes.",
+  input: import_zod26.z.object({
+    bundlePath: import_zod26.z.string().min(1).optional().describe(
+      "Absolute path to one knowledge base. Omit to stamp every pinned base."
+    ),
+    since: import_zod26.z.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."
+    )
+  }),
+  fromArgv: (argv, path, _stdin, bundleExplicit) => {
+    const since = argvFlag(argv, "--since");
+    return {
+      ...bundleExplicit ? { bundlePath: path } : {},
+      ...since !== void 0 ? { since } : {}
+    };
+  },
+  run: async ({ store }, { bundlePath: bundlePath2, since }) => {
+    const targets = bundlePath2 ? [bundlePath2] : (await readMergedPins(process.cwd())).pins.map(
+      (pin) => pin.absolutePath
+    );
+    if (since !== void 0 && DIGEST.test(since) && targets.length > 1) {
+      throw new KbStampDigestBaselineError(since);
+    }
+    const stamps = await Promise.all(
+      targets.map((target) => store.stamp(target))
+    );
+    if (since === void 0) {
+      return stamps.map((stamp) => ({ ...stamp, changed: null }));
+    }
+    const baseline = await readBaseline(since);
+    const reports = [];
+    for (const stamp of stamps) {
+      const before = baseline.byPath.get(stamp.path);
+      if (baseline.digest !== null) {
+        if (baseline.digest === stamp.digest) continue;
+        reports.push({ ...stamp, changed: null });
+        continue;
+      }
+      if (before && before.digest === stamp.digest) continue;
+      reports.push({ ...stamp, changed: changedIds(before?.records, stamp) });
+    }
+    return reports;
+  },
+  render: (result) => result.map((report) => {
+    const counts = `${report.recordCount} record(s), ${report.superseded} superseded`;
+    const head = `${report.path}  ${report.digest}  ${counts}${report.newestAt ? `  newest ${report.newestAt}` : ""}`;
+    return report.changed?.length ? `${head}
+  changed: ${report.changed.join(", ")}` : head;
+  }).join("\n")
+});
+function changedIds(before, stamp) {
+  const now = new Map(
+    stamp.records.map((record) => [record.conceptId, record.digest])
+  );
+  const ids = /* @__PURE__ */ new Set();
+  for (const [conceptId2, digest] of now) {
+    if (before?.get(conceptId2) !== digest) ids.add(conceptId2);
+  }
+  for (const conceptId2 of before?.keys() ?? []) {
+    if (!now.has(conceptId2)) ids.add(conceptId2);
+  }
+  return [...ids].sort();
+}
+async function readBaseline(since) {
+  if (DIGEST.test(since)) return { digest: since, byPath: /* @__PURE__ */ new Map() };
+  let parsed;
+  try {
+    parsed = JSON.parse(await (0, import_promises7.readFile)(since, "utf8"));
+  } catch {
+    throw new KbStampBaselineError(since);
+  }
+  const entries = Array.isArray(parsed) ? parsed : parsed?.stamps ?? [];
+  const byPath = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (typeof entry?.path !== "string" || typeof entry?.digest !== "string") {
+      continue;
+    }
+    byPath.set(entry.path, {
+      digest: entry.digest,
+      records: new Map(
+        (entry.records ?? []).map((record) => [
+          record.conceptId,
+          record.digest
+        ])
+      )
+    });
+  }
+  return { digest: null, byPath };
+}
+
 // src/commands/status.ts
-var import_zod25 = require("zod");
+var import_zod27 = require("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: import_zod25.z.object({
+  input: import_zod27.z.object({
     bundlePath,
     conceptId,
-    status: import_zod25.z.enum(KB_RECORD_STATUSES)
+    status: import_zod27.z.enum(KB_RECORD_STATUSES)
   }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
@@ -3603,13 +4387,13 @@ var statusCommand = define({
 });
 
 // src/commands/supersede.ts
-var import_zod26 = require("zod");
+var import_zod28 = require("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: import_zod26.z.object({ bundlePath, conceptId, replacementId: conceptId }),
+  input: import_zod28.z.object({ bundlePath, conceptId, replacementId: conceptId }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
     conceptId: argv[1],
@@ -3623,16 +4407,16 @@ var supersedeCommand = define({
 });
 
 // src/commands/sync-instructions.ts
-var import_zod27 = require("zod");
+var import_zod29 = require("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: import_zod27.z.object({
-    file: import_zod27.z.string().min(1).describe("The instruction file to edit in place."),
-    budgetTokens: import_zod27.z.number().int().positive().optional(),
-    fullUnderTokens: import_zod27.z.number().int().positive().optional(),
-    profile: import_zod27.z.string().optional()
+  input: import_zod29.z.object({
+    file: import_zod29.z.string().min(1).describe("The instruction file to edit in place."),
+    budgetTokens: import_zod29.z.number().int().positive().optional(),
+    fullUnderTokens: import_zod29.z.number().int().positive().optional(),
+    profile: import_zod29.z.string().optional()
   }),
   fromArgv: (argv) => {
     const budget = argvFlag(argv, "--budget");
@@ -3658,7 +4442,7 @@ var syncInstructionsCommand = define({
 });
 
 // src/commands/trace.ts
-var import_zod28 = require("zod");
+var import_zod30 = require("zod");
 
 // src/trace.ts
 var TRACE_EDGES = [
@@ -3714,11 +4498,11 @@ var traceCommand = define({
   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: import_zod28.z.object({
+  input: import_zod30.z.object({
     bundlePath,
     conceptId,
-    edges: import_zod28.z.array(import_zod28.z.enum(TRACE_EDGES)).optional(),
-    depth: import_zod28.z.number().int().positive().optional()
+    edges: import_zod30.z.array(import_zod30.z.enum(TRACE_EDGES)).optional(),
+    depth: import_zod30.z.number().int().positive().optional()
   }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
@@ -3740,37 +4524,37 @@ var traceCommand = define({
 });
 
 // src/commands/types.ts
-var import_zod29 = require("zod");
+var import_zod31 = require("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: import_zod29.z.object({}),
+  input: import_zod31.z.object({}),
   fromArgv: () => ({}),
   run: () => Promise.resolve(RECORD_TYPES)
 });
 
 // src/commands/unpin.ts
-var import_zod30 = require("zod");
+var import_zod32 = require("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: import_zod30.z.object({ bundlePath }),
+  input: import_zod32.z.object({ bundlePath }),
   fromArgv: (argv, path) => ({ bundlePath: argv[1] ?? path }),
   run: (_ctx, { bundlePath: path }) => unpinBase(process.cwd(), path)
 });
 
 // src/commands/validate.ts
-var import_zod31 = require("zod");
+var import_zod33 = require("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: import_zod31.z.object({ bundlePath }),
+  input: import_zod33.z.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.
@@ -3780,16 +4564,16 @@ var validateCommand = define({
 });
 
 // src/commands/verify.ts
-var import_zod32 = require("zod");
+var import_zod34 = require("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: import_zod32.z.object({
+  input: import_zod34.z.object({
     bundlePath,
     conceptId,
-    note: import_zod32.z.string().refine((s) => s.trim().length > 0, {
+    note: import_zod34.z.string().refine((s) => s.trim().length > 0, {
       message: "note must say what the check found"
     })
   }),
@@ -3809,15 +4593,15 @@ var verifyCommand = define({
 });
 
 // src/commands/write.ts
-var import_zod33 = require("zod");
+var import_zod35 = require("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: import_zod33.z.object({
+  input: import_zod35.z.object({
     bundlePath,
-    type: import_zod33.z.enum(KB_RECORD_TYPES),
+    type: import_zod35.z.enum(KB_RECORD_TYPES),
     input: composeInputSchema
   }),
   fromArgv: async (argv, path, stdin) => ({
@@ -3841,13 +4625,13 @@ var writeCommand = define({
 });
 
 // src/commands/write-decision.ts
-var import_zod34 = require("zod");
+var import_zod36 = require("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: import_zod34.z.object({ bundlePath, input: decisionInputSchema }),
+  input: import_zod36.z.object({ bundlePath, input: decisionInputSchema }),
   fromArgv: async (_argv, path, stdin) => ({
     bundlePath: path,
     input: JSON.parse(await stdin())
@@ -3887,6 +4671,7 @@ var KB_COMMANDS = [
   listCommand,
   readIndexCommand,
   logCommand,
+  stampCommand,
   validateCommand,
   doctorCommand,
   schemaCommand,
@@ -3902,9 +4687,8 @@ var KB_COMMANDS_BY_NAME = new Map(
 );
 
 // src/kb-store.ts
-var import_node_crypto2 = require("crypto");
-var import_promises6 = require("fs/promises");
-var import_node_path8 = require("path");
+var import_promises9 = require("fs/promises");
+var import_node_path11 = require("path");
 
 // src/markdown.ts
 var import_gray_matter = __toESM(require("gray-matter"), 1);
@@ -3931,9 +4715,41 @@ function parseMarkdownWithFrontmatter(text, schema) {
   };
 }
 
+// src/kb-stamp.ts
+var import_node_crypto4 = require("crypto");
+function sha2563(contents) {
+  return (0, import_node_crypto4.createHash)("sha256").update(contents).digest("hex");
+}
+function bundleStamp(records, superseded) {
+  const entries = [
+    ...records.map((hit) => ({
+      conceptId: hit.record.conceptId,
+      digest: `current:${sha2563(
+        stringifyMarkdownWithFrontmatter(
+          hit.record.body,
+          hit.record.frontmatter
+        )
+      )}`
+    })),
+    ...superseded.map((entry) => ({
+      conceptId: entry.conceptId,
+      digest: `superseded:${sha2563(JSON.stringify(entry))}`
+    }))
+  ].sort((a, b) => a.conceptId < b.conceptId ? -1 : 1);
+  return {
+    digest: sha2563(
+      entries.map((entry) => `${entry.conceptId}:${entry.digest}`).join("\n")
+    ),
+    records: entries
+  };
+}
+function bundleDigest(records, superseded) {
+  return bundleStamp(records, superseded).digest;
+}
+
 // src/search-index.ts
-var import_promises5 = require("fs/promises");
-var import_node_path7 = require("path");
+var import_promises8 = require("fs/promises");
+var import_node_path10 = require("path");
 var SEARCH_INDEX_FILE = ".index.sqlite";
 var COLLECTION = "kb";
 async function searchBase(bundlePath2, query, options = {}) {
@@ -3942,7 +4758,7 @@ async function searchBase(bundlePath2, query, options = {}) {
   let store = null;
   try {
     store = await qmd.createStore({
-      dbPath: (0, import_node_path7.join)(bundlePath2, SEARCH_INDEX_FILE),
+      dbPath: (0, import_node_path10.join)(bundlePath2, SEARCH_INDEX_FILE),
       config: {
         collections: {
           [COLLECTION]: {
@@ -3977,7 +4793,7 @@ async function searchBase(bundlePath2, query, options = {}) {
   }
 }
 async function isStale(bundlePath2) {
-  const indexAt = await (0, import_promises5.stat)((0, import_node_path7.join)(bundlePath2, SEARCH_INDEX_FILE)).then((s) => s.mtimeMs).catch(() => 0);
+  const indexAt = await (0, import_promises8.stat)((0, import_node_path10.join)(bundlePath2, SEARCH_INDEX_FILE)).then((s) => s.mtimeMs).catch(() => 0);
   if (!indexAt) return true;
   const { readdir: readdir2 } = await import("fs/promises");
   const names = (await readdir2(bundlePath2).catch(() => [])).filter(
@@ -3986,7 +4802,7 @@ async function isStale(bundlePath2) {
   let stale = false;
   await mapLimit(names, DEFAULT_IO_CONCURRENCY, async (name) => {
     if (stale) return;
-    const at = await (0, import_promises5.stat)((0, import_node_path7.join)(bundlePath2, name)).then((s) => s.mtimeMs).catch(() => 0);
+    const at = await (0, import_promises8.stat)((0, import_node_path10.join)(bundlePath2, name)).then((s) => s.mtimeMs).catch(() => 0);
     if (at > indexAt) stale = true;
   });
   return stale;
@@ -4100,8 +4916,8 @@ function byRank(left, right) {
   ) || left.record.conceptId.localeCompare(right.record.conceptId);
 }
 function typeRank(record) {
-  const index = TYPE_PRIORITY.indexOf(record.frontmatter.type);
-  return index === -1 ? TYPE_PRIORITY.length : index;
+  const index2 = TYPE_PRIORITY.indexOf(record.frontmatter.type);
+  return index2 === -1 ? TYPE_PRIORITY.length : index2;
 }
 
 // src/kb-links/inbound.ts
@@ -4264,7 +5080,7 @@ function appendUnionMergeLine(contents) {
 }
 
 // src/kb-store.ts
-var KB_DIR = (0, import_node_path8.join)(".strauss", "kb");
+var KB_DIR = (0, import_node_path11.join)(".strauss", "kb");
 var STORE_OWNED = /* @__PURE__ */ new Set([INDEX_FILE, LOG_FILE, SEARCH_INDEX_FILE]);
 var DEFAULT_LOAD_BUDGET = 25e3;
 var KbStore = class {
@@ -4295,7 +5111,7 @@ var KbStore = class {
     const conceptId2 = `${input.type}.${input.slug}`;
     const root = this.root(bundlePath2);
     const target = this.recordPath(bundlePath2, conceptId2);
-    await (0, import_promises6.mkdir)(root, { recursive: true });
+    await (0, import_promises9.mkdir)(root, { recursive: true });
     await this.publish(
       target,
       stringifyMarkdownWithFrontmatter(input.body, frontmatter),
@@ -4334,7 +5150,7 @@ var KbStore = class {
     const target = this.recordPath(bundlePath2, conceptId2);
     let raw;
     try {
-      raw = await (0, import_promises6.readFile)(target, "utf8");
+      raw = await (0, import_promises9.readFile)(target, "utf8");
     } catch {
       return null;
     }
@@ -4351,7 +5167,7 @@ var KbStore = class {
     const root = this.root(bundlePath2);
     let names;
     try {
-      names = await (0, import_promises6.readdir)(root);
+      names = await (0, import_promises9.readdir)(root);
     } catch {
       return [];
     }
@@ -4359,7 +5175,7 @@ var KbStore = class {
     const records = await mapLimit(
       wanted,
       DEFAULT_IO_CONCURRENCY,
-      async ({ name, conceptId: conceptId2 }) => this.parse(conceptId2, await (0, import_promises6.readFile)((0, import_node_path8.join)(root, name), "utf8"))
+      async ({ name, conceptId: conceptId2 }) => this.parse(conceptId2, await (0, import_promises9.readFile)((0, import_node_path11.join)(root, name), "utf8"))
     );
     return records.filter((record) => record !== null);
   }
@@ -4516,7 +5332,7 @@ ${answer}
       if (found.length) return found;
     }
     const lowered = needle.toLowerCase();
-    return bundle.filter((record) => matches(record, lowered));
+    return bundle.filter((record) => matches2(record, lowered));
   }
   /**
    * Anchor drift over the records about to be handed back. Like the search
@@ -4634,6 +5450,28 @@ ${answer}
       digest: bundleDigestValue
     };
   }
+  /**
+   * `load`'s digest without `load`'s bodies — the same records, adjudicated
+   * the same way, handed back as a stamp. Skips the anchor drift pass, which
+   * reads source files and only ever adds warnings: no warning reaches the
+   * digest, so the value is identical to the one `load` returns.
+   */
+  async stamp(bundlePath2) {
+    const bundle = await this.list(bundlePath2);
+    const adjudicated = adjudicate(bundle, bundle, /* @__PURE__ */ new Date());
+    const current = adjudicated.filter((hit) => hit.standing !== "superseded");
+    const superseded = adjudicated.filter((hit) => hit.standing === "superseded").map(stub);
+    const stamped = bundleStamp(current, superseded);
+    const dates = bundle.map((record) => record.frontmatter.generated?.at ?? null).filter((at) => typeof at === "string").sort();
+    return {
+      path: bundlePath2,
+      digest: stamped.digest,
+      recordCount: bundle.length,
+      superseded: superseded.length,
+      newestAt: dates.at(-1) ?? null,
+      records: stamped.records
+    };
+  }
   /** How a position was arrived at, as a timeline. See `trace.ts`. */
   async trace(bundlePath2, seedId, options = {}) {
     return trace(seedId, await this.list(bundlePath2), options);
@@ -4664,11 +5502,11 @@ ${answer}
   async readIndex(bundlePath2) {
     const root = this.root(bundlePath2);
     const expected = renderIndex(await this.list(bundlePath2));
-    const stored = await (0, import_promises6.readFile)((0, import_node_path8.join)(root, INDEX_FILE), "utf8").catch(
+    const stored = await (0, import_promises9.readFile)((0, import_node_path11.join)(root, INDEX_FILE), "utf8").catch(
       () => null
     );
     if (indexIsStale(stored, expected)) {
-      await this.publish((0, import_node_path8.join)(root, INDEX_FILE), expected, true, INDEX_FILE);
+      await this.publish((0, import_node_path11.join)(root, INDEX_FILE), expected, true, INDEX_FILE);
       this.logger.info?.({
         operation: "kb.index.repair",
         bundlePath: root,
@@ -4685,8 +5523,8 @@ ${answer}
    * knows which agent touched what. So a bad line is surfaced and left alone.
    */
   async readLog(bundlePath2) {
-    const raw = await (0, import_promises6.readFile)(
-      (0, import_node_path8.join)(this.root(bundlePath2), LOG_FILE),
+    const raw = await (0, import_promises9.readFile)(
+      (0, import_node_path11.join)(this.root(bundlePath2), LOG_FILE),
       "utf8"
     ).catch(() => "");
     const result = parseLog(raw);
@@ -4737,15 +5575,15 @@ ${answer}
   }
   async mutate(bundlePath2, conceptId2, change, entry, changeBody = (body) => body) {
     const target = this.recordPath(bundlePath2, conceptId2);
-    const before = await (0, import_promises6.readFile)(target, "utf8").catch(() => null);
+    const before = await (0, import_promises9.readFile)(target, "utf8").catch(() => null);
     if (before === null) throw new KbRecordNotFoundError(conceptId2);
     const parsed = this.parse(conceptId2, before);
     if (!parsed) throw new KbRecordNotFoundError(conceptId2);
     const frontmatter = change(parsed.frontmatter);
     const body = changeBody(parsed.body);
     const contents = stringifyMarkdownWithFrontmatter(body, frontmatter);
-    const witness = await (0, import_promises6.readFile)(target, "utf8").catch(() => null);
-    if (witness === null || digest(witness) !== digest(before)) {
+    const witness = await (0, import_promises9.readFile)(target, "utf8").catch(() => null);
+    if (witness === null || sha2563(witness) !== sha2563(before)) {
       throw new KbWriteConflictError(conceptId2);
     }
     await this.publish(target, contents, true, conceptId2);
@@ -4770,20 +5608,20 @@ ${answer}
    */
   async publish(target, contents, overwrite, conceptId2) {
     const staging = `${target}.${process.pid}.tmp`;
-    await (0, import_promises6.writeFile)(staging, contents, "utf8");
+    await (0, import_promises9.writeFile)(staging, contents, "utf8");
     try {
       if (overwrite) {
-        await (0, import_promises6.rename)(staging, target);
+        await (0, import_promises9.rename)(staging, target);
         return;
       }
-      await (0, import_promises6.link)(staging, target);
+      await (0, import_promises9.link)(staging, target);
     } catch (error) {
       if (error.code === "EEXIST") {
         throw new KbRecordAlreadyExistsError(conceptId2);
       }
       throw error;
     } finally {
-      await (0, import_promises6.unlink)(staging).catch(() => void 0);
+      await (0, import_promises9.unlink)(staging).catch(() => void 0);
     }
   }
   /**
@@ -4827,18 +5665,18 @@ ${answer}
    * file must not fail the mutation it guards.
    */
   async ensureGitattributes(root) {
-    const target = (0, import_node_path8.join)(root, GITATTRIBUTES_FILE);
+    const target = (0, import_node_path11.join)(root, GITATTRIBUTES_FILE);
     try {
       let existing;
       try {
-        existing = await (0, import_promises6.readFile)(target, "utf8");
+        existing = await (0, import_promises9.readFile)(target, "utf8");
       } catch (error) {
         if (error.code !== "ENOENT") throw error;
         existing = null;
       }
       if (existing === null) {
         try {
-          await (0, import_promises6.writeFile)(target, appendUnionMergeLine(""), {
+          await (0, import_promises9.writeFile)(target, appendUnionMergeLine(""), {
             encoding: "utf8",
             flag: "wx"
           });
@@ -4859,7 +5697,7 @@ ${answer}
         return;
       }
       if (!hasMergeDeclaration(existing)) {
-        await (0, import_promises6.appendFile)(target, appendUnionMergeLine(existing), "utf8");
+        await (0, import_promises9.appendFile)(target, appendUnionMergeLine(existing), "utf8");
         this.logger.info?.({
           operation: "kb.gitattributes.ensure",
           bundlePath: root,
@@ -4878,7 +5716,7 @@ ${answer}
   async record(root, entry) {
     await this.ensureGitattributes(root);
     const line = renderLogEntry({ at: (/* @__PURE__ */ new Date()).toISOString(), ...entry });
-    await (0, import_promises6.appendFile)((0, import_node_path8.join)(root, LOG_FILE), line, "utf8").catch((error) => {
+    await (0, import_promises9.appendFile)((0, import_node_path11.join)(root, LOG_FILE), line, "utf8").catch((error) => {
       this.logger.warn?.({
         operation: "kb.log.append",
         outcome: "failed",
@@ -4904,18 +5742,18 @@ ${answer}
     };
   }
   root(bundlePath2) {
-    return (0, import_node_path8.resolve)(bundlePath2);
+    return (0, import_node_path11.resolve)(bundlePath2);
   }
   // Concept ids are `<type>.<slug>` and map to a single file directly under the
   // bundle root; anything carrying a separator would escape it.
   recordPath(bundlePath2, conceptId2) {
-    if (conceptId2.includes(import_node_path8.sep) || conceptId2.includes("/")) {
+    if (conceptId2.includes(import_node_path11.sep) || conceptId2.includes("/")) {
       throw new KbInvalidConceptIdError(
         "concept id must not contain a path separator",
         { conceptId: conceptId2 }
       );
     }
-    return (0, import_node_path8.join)(this.root(bundlePath2), `${conceptId2}.md`);
+    return (0, import_node_path11.join)(this.root(bundlePath2), `${conceptId2}.md`);
   }
 };
 function estimateTokens(record) {
@@ -4942,7 +5780,7 @@ function stub(hit) {
     at: hit.record.frontmatter.generated?.at ?? null
   };
 }
-function matches(record, needle) {
+function matches2(record, needle) {
   const { title, description } = record.frontmatter;
   return [record.conceptId, title, description, record.body].some(
     (field) => field?.toLowerCase().includes(needle)
@@ -4953,28 +5791,9 @@ function normalizeActor(id) {
   if (colon === -1) return id.toLowerCase();
   return id.slice(0, colon + 1).toLowerCase() + id.slice(colon + 1);
 }
-function digest(contents) {
-  return (0, import_node_crypto2.createHash)("sha256").update(contents).digest("hex");
-}
-function bundleDigest(records, superseded) {
-  const entries = [
-    ...records.map(
-      (hit) => `${hit.record.conceptId}:current:${digest(
-        stringifyMarkdownWithFrontmatter(
-          hit.record.body,
-          hit.record.frontmatter
-        )
-      )}`
-    ),
-    ...superseded.map(
-      (entry) => `${entry.conceptId}:superseded:${digest(JSON.stringify(entry))}`
-    )
-  ].sort();
-  return digest(entries.join("\n"));
-}
 
 // src/version.ts
-var VERSION = true ? "0.1.15" : "0.0.0-dev";
+var VERSION = true ? "0.1.17" : "0.0.0-dev";
 
 // src/mcp.ts
 function createKbMcpServer() {