@saasontools/strauss-kb 0.1.15 → 0.1.17

package/dist/{chunk-KNIUBCZY.js → chunk-ZKIQOBHT.js}

@@ -43,7 +43,13 @@ var kbAnchorSchema = z.object({
   /** ISO 8601 timestamp of the last successful resolution. */
   resolved_at: z.string().min(1).optional(),
   /** Line count of the text the hash was taken over. */
-  lines: z.number().int().positive().optional()
+  lines: 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: z.enum(["tree-sitter", "regex"]).optional()
 }).strict();
 var kbLinkSchema = z.object({
   target: z.string().min(1),
@@ -709,18 +715,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();
@@ -747,7 +753,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]]
     )
@@ -799,13 +805,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"
   };
@@ -832,8 +838,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(
     [
@@ -849,7 +855,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 });
@@ -963,64 +969,577 @@ async function readAnchorFiles(files, read, concurrency = DEFAULT_IO_CONCURRENCY
   return new Map(wanted.map((file, at) => [file, results[at]]));
 }
 
+// src/grammars/store.ts
+import { createHash, randomBytes } from "crypto";
+import { mkdir as mkdir2, readFile as readFile2, rename, rm, writeFile } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { dirname, join as join2 } from "path";
+function grammarsCacheRoot(override) {
+  return override ?? process.env["STRAUSS_KB_GRAMMARS_DIR"] ?? join2(homedir2(), ".strauss", "grammars");
+}
+function grammarCachePath(root, language, sha2564, extension = "wasm") {
+  return join2(root, language, `${sha2564.slice(0, 12)}.${extension}`);
+}
+function sha256(bytes) {
+  return 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 readFile2(path);
+  } catch {
+    return false;
+  }
+  if (matches(bytes, entry)) return true;
+  await rm(path, { force: true });
+  return false;
+}
+async function writeCached(path, bytes) {
+  await mkdir2(dirname(path), { recursive: true });
+  const temporary = `${path}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
+  try {
+    await writeFile(temporary, bytes);
+    await rename(temporary, path);
+  } catch (error) {
+    await rm(temporary, { force: true });
+    throw error;
+  }
+}
+
+// src/grammars/manifest.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname as dirname2, join as join3 } from "path";
+import { fileURLToPath } from "url";
+
+// src/grammars/model.ts
+import { z as z4 } from "zod";
+var sha2562 = z4.string().regex(/^[0-9a-f]{64}$/);
+var grammarWasmSchema = z4.object({
+  url: z4.string().min(1),
+  sha256: sha2562,
+  bytes: z4.number().int().positive()
+});
+var grammarTagsSchema = z4.object({ url: z4.string().min(1), sha256: sha2562 });
+var grammarPackSchema = z4.object({
+  package: z4.string().min(1),
+  wasm: grammarWasmSchema,
+  tags: z4.array(grammarTagsSchema),
+  license: z4.string().min(1),
+  extensions: z4.array(z4.string().min(1))
+});
+var grammarManifestSchema = z4.object({
+  /** The runtime the packs were proved against. */
+  webTreeSitter: z4.string().min(1),
+  linguist: z4.object({ tag: z4.string().min(1), commit: z4.string().min(1) }),
+  packs: z4.record(z4.string().min(1), grammarPackSchema)
+});
+
+// src/grammars/manifest.ts
+var cached;
+function grammarManifest() {
+  cached ??= grammarManifestSchema.parse(
+    JSON.parse(readFileSync(grammarsDataPath("manifest.json"), "utf8"))
+  );
+  return cached;
+}
+function grammarsDataPath(...segments) {
+  let dir = dirname2(fileURLToPath(import.meta.url));
+  for (let up = 0; up < 5; up++) {
+    const candidate = join3(dir, "grammars");
+    if (existsSync(join3(candidate, "manifest.json")))
+      return join3(candidate, ...segments);
+    dir = dirname2(dir);
+  }
+  throw new Error("grammars/manifest.json is missing from the package");
+}
+
+// src/grammars/index.ts
+import { readFile as readFile3 } from "fs/promises";
+
+// 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/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 readFile3(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
+import { extname } from "path";
+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()[extname(file).toLowerCase()];
+  return language && hasQuery(language) ? language : void 0;
+}
+function treeSitterLanguages() {
+  return [...new Set(Object.values(extensionTable()))].filter(hasQuery).sort();
+}
+
+// src/tree-sitter-resolver/resolver.ts
+import { createHash as createHash2 } from "crypto";
+import { Language, Parser, Query } from "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 Parser.init();
+        this.parser = new 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 Language.load(pack2.wasm);
+    } catch (error) {
+      noteRejectedGrammar(language, why(error));
+      return null;
+    }
+    try {
+      return { language: grammar, query: new 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}:${createHash2("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
-import { createHash } from "crypto";
+import { createHash as createHash3 } from "crypto";
 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 } };
 }
@@ -1035,8 +1554,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 === "{") {
@@ -1045,10 +1564,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;
 }
@@ -1057,22 +1576,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);
 }
@@ -1096,11 +1615,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)) {
@@ -1117,34 +1636,79 @@ 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:${createHash("sha256").update(text.replace(/\r\n/g, "\n")).digest("hex")}`;
+  return `sha256:${createHash3("sha256").update(text.replace(/\r\n/g, "\n")).digest("hex")}`;
 }
 function resolveAnchor(source, anchor, resolver = regexResolver) {
+  const outcome = resolveAnchorSpan(source, anchor, [resolver]);
+  return outcome.ok ? outcome.span : null;
+}
+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)
+      }
     };
   }
-  return resolver.resolve(normalized, anchor.symbol);
+  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 { 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;
@@ -1182,12 +1746,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);
@@ -1216,12 +1784,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 {
-    hash: hashAnchorText(resolved.text),
-    lines: resolved.endLine - resolved.startLine + 1
+    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 {
+    ...current.resolver ? { resolver: current.resolver } : {},
+    ...current.hash !== anchor.hash && resolverChanged(source, anchor, current.resolver) ? { reason: "resolver-changed" } : {}
   };
 }
 function compared(anchor, current, extra = {}) {
@@ -1233,30 +1811,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
@@ -1273,6 +1869,8 @@ var ErrorTypes = /* @__PURE__ */ ((ErrorTypes2) => {
   ErrorTypes2["KbPackBudgetExceeded"] = "KbPackBudgetExceeded";
   ErrorTypes2["KbRecordNotFound"] = "KbRecordNotFound";
   ErrorTypes2["KbSelfVerification"] = "KbSelfVerification";
+  ErrorTypes2["KbStampBaselineUnreadable"] = "KbStampBaselineUnreadable";
+  ErrorTypes2["KbStampDigestBaselineAmbiguous"] = "KbStampDigestBaselineAmbiguous";
   ErrorTypes2["KbUnknownLinkRel"] = "KbUnknownLinkRel";
   ErrorTypes2["KbWriteConflict"] = "KbWriteConflict";
   return ErrorTypes2;
@@ -1427,13 +2025,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);
@@ -1444,9 +2072,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]) : {}
@@ -1477,15 +2105,15 @@ var KbBaseFrozenError = class extends Error {
 };
 
 // src/kb-pins/model.ts
-import { join as join2 } from "path";
-import { z as z4 } from "zod";
-var PINS_FILE = join2(".strauss", "kb-pins.json");
-var PINS_LOCAL_FILE = join2(".strauss", "kb-pins.local.json");
+import { join as join4 } from "path";
+import { z as z5 } from "zod";
+var PINS_FILE = join4(".strauss", "kb-pins.json");
+var PINS_LOCAL_FILE = join4(".strauss", "kb-pins.local.json");
 var PIN_LAYERS = ["project", "local", "user"];
-var pinSchema = z4.object({
+var pinSchema = z5.object({
   /** Relative to the manifest's root, so the file is committable. */
-  path: z4.string().min(1),
-  pinnedAt: z4.string().min(1).optional(),
+  path: z5.string().min(1),
+  pinnedAt: z5.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
@@ -1495,7 +2123,7 @@ var pinSchema = z4.object({
    * Absent: the profile's full-under threshold decides. Invalid values
    * degrade to absent rather than failing the manifest.
    */
-  mode: z4.enum(["full", "index"]).optional().catch(void 0),
+  mode: z5.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
@@ -1503,17 +2131,17 @@ var pinSchema = z4.object({
    * that skill at point of use than pinned at all — pins are what every
    * session should see.
    */
-  profiles: z4.array(z4.string()).optional().catch(void 0),
+  profiles: z5.array(z5.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: z4.boolean().optional().catch(void 0)
+  frozen: z5.boolean().optional().catch(void 0)
 }).passthrough();
-var pinsManifestSchema = z4.object({
-  pins: z4.array(pinSchema).default([]),
+var pinsManifestSchema = z5.object({
+  pins: z5.array(pinSchema).default([]),
   /**
    * Per-repo budgets for the `context` command, keyed by profile —
    * `"session-start"`, `"compact"`, `"turn"`, or `"default"` for all of
@@ -1522,21 +2150,21 @@ var pinsManifestSchema = z4.object({
    * the index at every session start. `contextProfileBudgets` does the
    * tolerant read.
    */
-  context: z4.unknown().optional()
+  context: z5.unknown().optional()
 }).passthrough();
 
 // src/kb-pins/layers.ts
-import { mkdir as mkdir2, readFile as readFile2, writeFile } from "fs/promises";
-import { homedir as homedir2 } from "os";
-import { dirname, isAbsolute as isAbsolute2, join as join3, relative as relative2, resolve as resolve2, sep as sep2 } from "path";
+import { mkdir as mkdir3, readFile as readFile4, writeFile as writeFile2 } from "fs/promises";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname3, isAbsolute as isAbsolute2, join as join5, relative as relative2, resolve as resolve2, sep as sep2 } from "path";
 function userRoot() {
-  return process.env.STRAUSS_KB_USER_ROOT || homedir2();
+  return process.env.STRAUSS_KB_USER_ROOT || homedir3();
 }
 function layerRoot(workspaceDir, layer) {
   return layer === "user" ? userRoot() : resolve2(workspaceDir);
 }
 function layerFile(workspaceDir, layer) {
-  return join3(
+  return join5(
     layerRoot(workspaceDir, layer),
     layer === "local" ? PINS_LOCAL_FILE : PINS_FILE
   );
@@ -1545,7 +2173,7 @@ async function readPinsLayer(workspaceDir, layer) {
   const file = layerFile(workspaceDir, layer);
   let raw;
   try {
-    raw = await readFile2(file, "utf8");
+    raw = await readFile4(file, "utf8");
   } catch {
     return { pins: [] };
   }
@@ -1569,8 +2197,8 @@ async function readPinsLayer(workspaceDir, layer) {
 }
 async function writePinsLayer(workspaceDir, layer, manifest) {
   const file = layerFile(workspaceDir, layer);
-  await mkdir2(dirname(file), { recursive: true });
-  await writeFile(file, `${JSON.stringify(manifest, null, 2)}
+  await mkdir3(dirname3(file), { recursive: true });
+  await writeFile2(file, `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
 }
 function resolvePinPath(rootDir, path) {
@@ -1795,8 +2423,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)
@@ -1827,13 +2455,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
@@ -1904,7 +2532,7 @@ function indexIsStale(stored, expected) {
 }
 
 // src/kb-context.ts
-import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import { readFile as readFile5, writeFile as writeFile3 } from "fs/promises";
 var HEADING2 = "## Knowledge bases (pinned)";
 var DEFAULT_CONTEXT_BUDGET = 4e3;
 var CONTEXT_PROFILES = {
@@ -2108,13 +2736,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 readFile3(file, "utf8").catch(() => null);
+  const existing = await readFile5(file, "utf8").catch(() => null);
   const region = block ? `${CONTEXT_BEGIN}
 ${block.trim()}
 ${CONTEXT_END}` : null;
   if (existing === null) {
     if (!region) return { file, action: "unchanged" };
-    await writeFile2(file, `${region}
+    await writeFile3(file, `${region}
 `, "utf8");
     return { file, action: "created" };
   }
@@ -2125,11 +2753,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 writeFile2(file, next, "utf8");
+    await writeFile3(file, next, "utf8");
     return { file, action: region ? "replaced" : "removed" };
   }
   if (!region) return { file, action: "unchanged" };
-  await writeFile2(
+  await writeFile3(
     file,
     `${existing.replace(/\n*$/, "\n\n")}${region}
 `,
@@ -2333,6 +2961,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,
@@ -2368,6 +3008,7 @@ function doctor(bundle, options = {}) {
     counts,
     groups,
     findingCount,
+    anchorResolvers: anchorResolverCounts(bundle),
     healthy: findingCount === 0
   };
 }
@@ -2614,9 +3255,9 @@ function ageInDays(record, now) {
 }
 
 // src/kb-log.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var LOG_FILE = "log.jsonl";
-var kbLogEntrySchema = z5.object({
+var kbLogEntrySchema = z6.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
@@ -2625,12 +3266,12 @@ var kbLogEntrySchema = z5.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: z5.iso.datetime(),
-  by: z5.string().min(1),
-  operation: z5.string().min(1),
-  conceptId: z5.string().min(1),
+  at: z6.iso.datetime(),
+  by: z6.string().min(1),
+  operation: z6.string().min(1),
+  conceptId: z6.string().min(1),
   /** Second concept id, where the operation relates two — supersession. */
-  target: z5.string().min(1).optional()
+  target: z6.string().min(1).optional()
 }).strict();
 function renderLogEntry(entry) {
   return `${JSON.stringify(kbLogEntrySchema.parse(entry))}
@@ -2640,18 +3281,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);
@@ -2666,14 +3307,14 @@ function parseLog(raw) {
 }
 
 // src/json-schema.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 function kbJsonSchemas() {
   return {
-    recordFrontmatter: z6.toJSONSchema(kbRecordFrontmatterSchema, {
+    recordFrontmatter: z7.toJSONSchema(kbRecordFrontmatterSchema, {
       io: "input"
     }),
-    composeInput: z6.toJSONSchema(composeInputSchema, { io: "input" }),
-    logEntry: z6.toJSONSchema(kbLogEntrySchema, { io: "input" })
+    composeInput: z7.toJSONSchema(composeInputSchema, { io: "input" }),
+    logEntry: z7.toJSONSchema(kbLogEntrySchema, { io: "input" })
   };
 }
 
@@ -2726,13 +3367,13 @@ function byGeneratedAt(left, right) {
 }
 
 // src/commands/anchor-resolve.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // src/commands/model.ts
-import { z as z7 } from "zod";
-var bundlePath = z7.string().min(1).describe("Absolute path to the knowledge base directory.");
-var conceptId = z7.string().min(1).describe("e.g. decision.cursor-v2");
-var REPO_ROOT = z7.string().min(1).optional().describe(
+import { z as z8 } from "zod";
+var bundlePath = z8.string().min(1).describe("Absolute path to the knowledge base directory.");
+var conceptId = z8.string().min(1).describe("e.g. decision.cursor-v2");
+var REPO_ROOT = z8.string().min(1).optional().describe(
   "Where the anchored source lives, for the drift check. Defaults to the working directory."
 );
 function define(command) {
@@ -2755,22 +3396,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: z8.object({
+  input: z9.object({
     bundlePath,
     conceptId,
-    repoRoot: z8.string().min(1).optional(),
-    offline: z8.boolean().optional().describe(
+    repoRoot: z9.string().min(1).optional(),
+    offline: z9.boolean().optional().describe(
       "Resolve foreign anchors from the local repo cache only, never fetching."
     ),
-    rebaseline: z8.boolean().optional().describe(
+    rebaseline: z9.boolean().optional().describe(
       "Accept the current code as the new baseline for anchors that drifted."
     ),
-    restamp: z8.boolean().optional().describe(
+    restamp: z9.boolean().optional().describe(
       "Refresh `resolved_at` on anchors that already match. Off by default, so a green run writes nothing."
     )
   }),
@@ -2799,6 +3448,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,
@@ -2815,27 +3469,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;
@@ -2846,6 +3508,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 } : {}
         });
@@ -2853,7 +3519,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,
@@ -2869,6 +3535,7 @@ var anchorResolveCommand = define({
         ...base2,
         state: "match",
         currentHash,
+        ...producedBy ? { resolver: producedBy } : {},
         ...pinned ? { remoteState: "matches-ref" } : {}
       });
       const refresh = restamp || anchor.resolved_at === void 0;
@@ -2886,19 +3553,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()
         );
@@ -2909,17 +3578,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:
@@ -2935,13 +3612,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) {
@@ -2991,13 +3668,13 @@ async function readSources(anchors, root, offline) {
 }
 
 // src/commands/answer.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var answerCommand = define({
   name: "answer",
   tool: "kb_answer",
   usage: "answer <concept-id> <answer...>",
   description: "Resolve an open question: set status, stamp who and when, append an Answer section. If the answer overturns a decision or assumption, supersede that record explicitly.",
-  input: z9.object({ bundlePath, conceptId, answer: z9.string().min(1) }),
+  input: z10.object({ bundlePath, conceptId, answer: z10.string().min(1) }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
     conceptId: argv[1],
@@ -3011,27 +3688,27 @@ var answerCommand = define({
 });
 
 // src/commands/backlinks.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var backlinksCommand = define({
   name: "backlinks",
   tool: "kb_backlinks",
   usage: "backlinks <concept-id>",
   description: "Who points at this record: every inbound typed causal link (`strauss_links`), one hop, every rel including `related_to`, each with its rel and the standing of the record that made it. Use it when you need the exact edges \u2014 reviewing or renaming a record.",
-  input: z10.object({ bundlePath, conceptId }),
+  input: z11.object({ bundlePath, conceptId }),
   fromArgv: (argv, path) => ({ bundlePath: path, conceptId: argv[1] }),
   run: async ({ store }, { bundlePath: path, conceptId: id }) => store.backlinks(path, id)
 });
 
 // src/commands/catalog.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var catalogCommand = define({
   name: "catalog",
   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: z11.object({
+  input: z12.object({
     bundlePath,
-    type: z11.enum(KB_RECORD_TYPES).optional()
+    type: z12.enum(KB_RECORD_TYPES).optional()
   }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
@@ -3086,26 +3763,26 @@ function count(value, noun) {
 }
 
 // src/commands/context.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 var contextCommand = define({
   name: "context",
   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: z12.object({
-    budgetTokens: z12.number().int().positive().optional().describe(
+  input: z13.object({
+    budgetTokens: z13.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: z12.number().int().positive().optional().describe(
+    fullUnderTokens: z13.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: z12.string().optional().describe(
+    profile: z13.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: z12.enum(["markdown", "json"]).optional().describe(
+    format: z13.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: z12.string().optional().describe(
+    event: z13.string().optional().describe(
       "hookEventName stamped into the JSON envelope. Only meaningful with format=json."
     )
   }),
@@ -3141,14 +3818,14 @@ var contextCommand = define({
 });
 
 // src/commands/doctor.ts
-import { z as z13 } from "zod";
-var days = (what, fallback) => z13.number().int().positive().optional().describe(`${what} Defaults to ${fallback}.`);
+import { z as z14 } from "zod";
+var days = (what, fallback) => z14.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: z13.object({
+  input: z14.object({
     bundlePath,
     repoRoot: REPO_ROOT,
     expiringDays: days(
@@ -3163,10 +3840,10 @@ var doctorCommand = define({
       "How long a record may stay `open` or `proposed` before `aging` reports it, in days.",
       DEFAULT_AGING_DAYS
     ),
-    offline: z13.boolean().optional().describe(
+    offline: z14.boolean().optional().describe(
       "Read foreign anchors from the local repo cache only, never fetching."
     ),
-    strict: z13.boolean().optional().describe(
+    strict: z14.boolean().optional().describe(
       "Turn an expired record into a non-zero exit for the CLI. No effect on the report itself."
     )
   }),
@@ -3209,7 +3886,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
@@ -3227,12 +3910,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) {
@@ -3244,6 +3930,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.`
@@ -3252,19 +3939,19 @@ function render2(result) {
 }
 
 // src/commands/impact.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 var impactCommand = define({
   name: "impact",
   tool: "kb_impact",
   usage: "impact <concept-id> [--depth N] [--rels a,b]",
   description: "What breaks if this record changes: its transitive set of dependants, each with its standing. Each rel declares which of its ends depends on the other, and the walk follows each rel in its own direction. Naming `related_to` or an unknown rel in `rels` is an error. kb_backlinks gives one flat hop.",
-  input: z14.object({
+  input: z15.object({
     bundlePath,
     conceptId,
-    depth: z14.number().int().positive().optional().describe(
+    depth: z15.number().int().positive().optional().describe(
       "Hops out from the record. Unbounded when omitted; a walk this cuts reports truncated: true."
     ),
-    rels: z14.array(z14.enum(KB_CAUSAL_LINK_RELS)).optional().describe(
+    rels: z15.array(z15.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."
     )
   }),
@@ -3285,13 +3972,13 @@ var impactCommand = define({
 });
 
 // src/commands/list.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "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: z15.object({ bundlePath, type: z15.enum(KB_RECORD_TYPES).optional() }),
+  input: z16.object({ bundlePath, type: z16.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,
@@ -3303,17 +3990,17 @@ var listCommand = define({
 });
 
 // src/commands/load.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 var loadCommand = define({
   name: "load",
   tool: "kb_load",
   usage: "load [type] [--budget N | --all] [--repo-root PATH]",
   description: "Load the whole base, each record with its standing \u2014 call it first, at the point of use, since compaction drops it. Superseded records arrive as stubs; kb_trace has the history. Over budget it refuses: kb_catalog, then kb_pack, or narrow with `type`; `all` bypasses. Never read record files directly \u2014 only kb_* tools resolve supersession. `digest` stamps the base's content, so hooks know when to reload.",
-  input: z16.object({
+  input: z17.object({
     bundlePath,
-    type: z16.enum(KB_RECORD_TYPES).optional(),
-    budgetTokens: z16.number().int().positive().optional().describe("Approximate token ceiling. Defaults to 25000."),
-    all: z16.boolean().optional().describe(
+    type: z17.enum(KB_RECORD_TYPES).optional(),
+    budgetTokens: z17.number().int().positive().optional().describe("Approximate token ceiling. Defaults to 25000."),
+    all: z17.boolean().optional().describe(
       "Loads the entire base regardless of size, bypassing the token budget; mutually exclusive with budgetTokens."
     ),
     repoRoot: REPO_ROOT
@@ -3355,25 +4042,25 @@ var loadCommand = define({
 });
 
 // src/commands/log.ts
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 var logCommand = define({
   name: "log",
   tool: "kb_log",
   usage: "log",
   description: "Who touched what, and when. Append-only; malformed lines are reported, never repaired.",
-  input: z17.object({ bundlePath }),
+  input: z18.object({ bundlePath }),
   fromArgv: (_argv, path) => ({ bundlePath: path }),
   run: ({ store }, { bundlePath: path }) => store.readLog(path)
 });
 
 // src/commands/no-decision.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 var noDecisionCommand = define({
   name: "no-decision",
   tool: "kb_no_decision",
   usage: "no-decision <reason...>",
   description: "Record in one sentence that a piece of work had nothing to decide. Idempotent.",
-  input: z18.object({ bundlePath, reason: z18.string().min(1) }),
+  input: z19.object({ bundlePath, reason: z19.string().min(1) }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
     reason: argv.slice(1).join(" ").trim()
@@ -3390,20 +4077,20 @@ var noDecisionCommand = define({
 });
 
 // src/commands/pack.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 var packCommand = define({
   name: "pack",
   tool: "kb_pack",
   usage: "pack <conceptId> [--hops N] [--max-nodes N] [--budget N]",
   description: "Bounded neighbourhood around one record: within `hops`, ranked, cut to `maxNodes`, with every cut record named under Excluded. Use when the base is over kb_load's budget and the work centres on a record you can name. Refuses over budget rather than truncating. Everything below the header is byte-stable across runs. Resolves supersession like kb_load.",
-  input: z19.object({
+  input: z20.object({
     bundlePath,
     conceptId,
-    hops: z19.number().int().positive().optional().describe("How far from the root the walk may reach. Defaults to 2."),
-    maxNodes: z19.number().int().positive().optional().describe(
+    hops: z20.number().int().positive().optional().describe("How far from the root the walk may reach. Defaults to 2."),
+    maxNodes: z20.number().int().positive().optional().describe(
       "How many records the pack may hold, root included. Defaults to 20."
     ),
-    budgetTokens: z19.number().int().positive().optional().describe(
+    budgetTokens: z20.number().int().positive().optional().describe(
       "Approximate token ceiling over what is actually emitted. Defaults to 25000."
     )
   }),
@@ -3490,22 +4177,22 @@ function warningLabel(warning) {
 }
 
 // src/commands/pin.ts
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 var pinCommand = define({
   name: "pin",
   tool: "kb_pin",
   usage: "pin [bundle-path] [--mode full|index] [--profiles a,b] [--local|--user] [--frozen|--unfreeze]",
   description: "Pin a base into a workspace manifest so kb_context surfaces it. Layers, nearest wins: project `.strauss/kb-pins.json` (default), `--local` (personal, gitignored), `--user` (`~/.strauss`). Idempotent; `--mode full|index`, `--profiles`, `--frozen`/`--unfreeze` update only those fields. A path with no records pins with a warning. Never touches the base itself.",
-  input: z20.object({
+  input: z21.object({
     bundlePath,
-    mode: z20.enum(["full", "index"]).optional().describe(
+    mode: z21.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: z20.array(z20.string()).optional().describe("Context profiles this pin surfaces in. Absent: all of them."),
-    layer: z20.enum(["project", "local", "user"]).optional().describe(
+    profiles: z21.array(z21.string()).optional().describe("Context profiles this pin surfaces in. Absent: all of them."),
+    layer: z21.enum(["project", "local", "user"]).optional().describe(
       "Which manifest to write: project (committed, default), local (personal, gitignored), user (~/.strauss, every workspace)."
     ),
-    frozen: z20.boolean().optional().describe(
+    frozen: z21.boolean().optional().describe(
       "true: the base is concluded \u2014 writes against it refuse while pinned. false: lift a freeze."
     )
   }),
@@ -3534,29 +4221,29 @@ var pinCommand = define({
 });
 
 // src/commands/pins.ts
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 var pinsCommand = define({
   name: "pins",
   tool: "kb_pins",
   usage: "pins",
   description: "Every pinned base across the manifest layers, with its layer and whether it resolves to records. Takes no bundlePath.",
-  input: z21.object({}),
+  input: z22.object({}),
   fromArgv: () => ({}),
   run: ({ store }) => listPins(store, process.cwd())
 });
 
 // src/commands/query.ts
-import { z as z22 } from "zod";
+import { z as z23 } from "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: z22.object({
+  input: z23.object({
     bundlePath,
-    text: z22.string().optional(),
-    type: z22.enum(KB_RECORD_TYPES).optional(),
-    includeNonCurrent: z22.boolean().optional(),
+    text: z23.string().optional(),
+    type: z23.enum(KB_RECORD_TYPES).optional(),
+    includeNonCurrent: z23.boolean().optional(),
     repoRoot: REPO_ROOT
   }),
   // `--repo-root` is a flag, so its value must not fall into the search text.
@@ -3588,40 +4275,138 @@ var queryCommand = define({
 });
 
 // src/commands/read-index.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 var readIndexCommand = define({
   name: "index",
   tool: "kb_index",
   usage: "index",
   description: "The index \u2014 title, type, status, description per record \u2014 rebuilt if stale. Cheapest re-orientation after compaction: call it (or kb_context) first, then kb_load or fetch by id.",
-  input: z23.object({ bundlePath }),
+  input: z24.object({ bundlePath }),
   fromArgv: (_argv, path) => ({ bundlePath: path }),
   run: ({ store }, { bundlePath: path }) => store.readIndex(path)
 });
 
 // src/commands/schema.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 var schemaCommand = define({
   name: "schema",
   tool: "kb_schema",
   usage: "schema",
   description: "JSON Schema for frontmatter, write input, and log entries, generated from the enforcing code.",
-  input: z24.object({}),
+  input: z25.object({}),
   fromArgv: () => ({}),
   run: () => Promise.resolve(kbJsonSchemas())
 });
 
+// src/commands/stamp.ts
+import { readFile as readFile6 } from "fs/promises";
+import { z as z26 } from "zod";
+var DIGEST = /^[0-9a-f]{64}$/;
+var stampCommand = define({
+  name: "stamp",
+  tool: "kb_stamp",
+  usage: "stamp [--bundle PATH] [--since DIGEST|FILE]",
+  description: "Content stamp of a base \u2014 `load`'s digest, record counts, per-record digests \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: z26.object({
+    bundlePath: z26.string().min(1).optional().describe(
+      "Absolute path to one knowledge base. Omit to stamp every pinned base."
+    ),
+    since: z26.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 readFile6(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
-import { z as z25 } from "zod";
+import { z as z27 } from "zod";
 var statusCommand = define({
   name: "status",
   tool: "kb_status",
   usage: "status <concept-id> <status>",
   description: "Move a record's status. Compare-and-swap: a concurrent change fails instead of being overwritten.",
-  input: z25.object({
+  input: z27.object({
     bundlePath,
     conceptId,
-    status: z25.enum(KB_RECORD_STATUSES)
+    status: z27.enum(KB_RECORD_STATUSES)
   }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
@@ -3636,13 +4421,13 @@ var statusCommand = define({
 });
 
 // src/commands/supersede.ts
-import { z as z26 } from "zod";
+import { z as z28 } from "zod";
 var supersedeCommand = define({
   name: "supersede",
   tool: "kb_supersede",
   usage: "supersede <concept-id> <replacement-id>",
   description: "Mark a record superseded by another, linked in both directions. Use instead of editing a record whose meaning changed.",
-  input: z26.object({ bundlePath, conceptId, replacementId: conceptId }),
+  input: z28.object({ bundlePath, conceptId, replacementId: conceptId }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
     conceptId: argv[1],
@@ -3656,16 +4441,16 @@ var supersedeCommand = define({
 });
 
 // src/commands/sync-instructions.ts
-import { z as z27 } from "zod";
+import { z as z29 } from "zod";
 var syncInstructionsCommand = define({
   name: "sync-instructions",
   usage: "sync-instructions <file> [--profile NAME] [--budget N] [--full-under N]",
   description: "CLI-only: plant the kb_context block between sentinel comments in AGENTS.md or CLAUDE.md, idempotently.",
-  input: z27.object({
-    file: z27.string().min(1).describe("The instruction file to edit in place."),
-    budgetTokens: z27.number().int().positive().optional(),
-    fullUnderTokens: z27.number().int().positive().optional(),
-    profile: z27.string().optional()
+  input: z29.object({
+    file: z29.string().min(1).describe("The instruction file to edit in place."),
+    budgetTokens: z29.number().int().positive().optional(),
+    fullUnderTokens: z29.number().int().positive().optional(),
+    profile: z29.string().optional()
   }),
   fromArgv: (argv) => {
     const budget = argvFlag(argv, "--budget");
@@ -3691,17 +4476,17 @@ var syncInstructionsCommand = define({
 });
 
 // src/commands/trace.ts
-import { z as z28 } from "zod";
+import { z as z30 } from "zod";
 var traceCommand = define({
   name: "trace",
   tool: "kb_trace",
   usage: "trace <concept-id> [edges...]",
   description: 'Timeline of how a position was reached, ordered by write time, following supersession, shared anchors and shared sources. Includes rejected, draft and superseded records \u2014 in a history they are the content. For "why is it like this"; kb_load answers "what holds now".',
-  input: z28.object({
+  input: z30.object({
     bundlePath,
     conceptId,
-    edges: z28.array(z28.enum(TRACE_EDGES)).optional(),
-    depth: z28.number().int().positive().optional()
+    edges: z30.array(z30.enum(TRACE_EDGES)).optional(),
+    depth: z30.number().int().positive().optional()
   }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
@@ -3723,37 +4508,37 @@ var traceCommand = define({
 });
 
 // src/commands/types.ts
-import { z as z29 } from "zod";
+import { z as z31 } from "zod";
 var typesCommand = define({
   name: "types",
   tool: "kb_types",
   usage: "types",
   description: "The twelve record types with their purpose, body sections, and starting status. Read this before writing rather than guessing headings \u2014 a section the type does not define is rejected.",
-  input: z29.object({}),
+  input: z31.object({}),
   fromArgv: () => ({}),
   run: () => Promise.resolve(RECORD_TYPES)
 });
 
 // src/commands/unpin.ts
-import { z as z30 } from "zod";
+import { z as z32 } from "zod";
 var unpinCommand = define({
   name: "unpin",
   tool: "kb_unpin",
   usage: "unpin [bundle-path]",
   description: "Remove a base from every manifest layer that holds it. Reports the layers touched.",
-  input: z30.object({ bundlePath }),
+  input: z32.object({ bundlePath }),
   fromArgv: (argv, path) => ({ bundlePath: argv[1] ?? path }),
   run: (_ctx, { bundlePath: path }) => unpinBase(process.cwd(), path)
 });
 
 // src/commands/validate.ts
-import { z as z31 } from "zod";
+import { z as z33 } from "zod";
 var validateCommand = define({
   name: "validate",
   tool: "kb_validate",
   usage: "validate",
   description: "Check pointers no single record can see: supersession links that disagree between the two records, typed causal links, and assumptions that cite sources. Each finding carries a severity: errors fail the exit code, warnings do not.",
-  input: z31.object({ bundlePath }),
+  input: z33.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.
@@ -3763,16 +4548,16 @@ var validateCommand = define({
 });
 
 // src/commands/verify.ts
-import { z as z32 } from "zod";
+import { z as z34 } from "zod";
 var verifyCommand = define({
   name: "verify",
   tool: "kb_verify",
   usage: "verify <concept-id> --note <text>",
   description: "Append a verified[] event: who checked, when, and what was found. Append-only. A record's own generator is refused unless the actor is `human:`-prefixed.",
-  input: z32.object({
+  input: z34.object({
     bundlePath,
     conceptId,
-    note: z32.string().refine((s) => s.trim().length > 0, {
+    note: z34.string().refine((s) => s.trim().length > 0, {
       message: "note must say what the check found"
     })
   }),
@@ -3792,15 +4577,15 @@ var verifyCommand = define({
 });
 
 // src/commands/write.ts
-import { z as z33 } from "zod";
+import { z as z35 } from "zod";
 var writeCommand = define({
   name: "write",
   tool: "kb_write",
   usage: "write <type> < record.json",
   description: "Write one record. Search first \u2014 a duplicate concept id is rejected, not overwritten; kb_types lists each type's sections. An unsourced claim is an `assumption` with assumption: true, never a vague `fact`. Conflicting records get a `risk`, `open-question`, or superseding `decision`. Prefer a new short record over overloading one. Never delete; supersede.",
-  input: z33.object({
+  input: z35.object({
     bundlePath,
-    type: z33.enum(KB_RECORD_TYPES),
+    type: z35.enum(KB_RECORD_TYPES),
     input: composeInputSchema
   }),
   fromArgv: async (argv, path, stdin) => ({
@@ -3824,13 +4609,13 @@ var writeCommand = define({
 });
 
 // src/commands/write-decision.ts
-import { z as z34 } from "zod";
+import { z as z36 } from "zod";
 var writeDecisionCommand = define({
   name: "write-decision",
   tool: "kb_write_decision",
   usage: "write-decision < decision.json",
   description: "Write a decision, with `alternative` (what was rejected and why) and `impact` as fields. Record one when a later reader would otherwise simplify the constraint away; skip when the diff already answers it. `sources` for material read, `anchors` for code, `relatedConceptIds` for records.",
-  input: z34.object({ bundlePath, input: decisionInputSchema }),
+  input: z36.object({ bundlePath, input: decisionInputSchema }),
   fromArgv: async (_argv, path, stdin) => ({
     bundlePath: path,
     input: JSON.parse(await stdin())
@@ -3870,6 +4655,7 @@ var KB_COMMANDS = [
   listCommand,
   readIndexCommand,
   logCommand,
+  stampCommand,
   validateCommand,
   doctorCommand,
   schemaCommand,
@@ -3911,7 +4697,7 @@ function parseMarkdownWithFrontmatter(text, schema) {
 
 // src/search-index.ts
 import { stat as stat2 } from "fs/promises";
-import { join as join4 } from "path";
+import { join as join6 } from "path";
 var SEARCH_INDEX_FILE = ".index.sqlite";
 var COLLECTION = "kb";
 async function searchBase(bundlePath2, query, options = {}) {
@@ -3920,7 +4706,7 @@ async function searchBase(bundlePath2, query, options = {}) {
   let store = null;
   try {
     store = await qmd.createStore({
-      dbPath: join4(bundlePath2, SEARCH_INDEX_FILE),
+      dbPath: join6(bundlePath2, SEARCH_INDEX_FILE),
       config: {
         collections: {
           [COLLECTION]: {
@@ -3955,7 +4741,7 @@ async function searchBase(bundlePath2, query, options = {}) {
   }
 }
 async function isStale(bundlePath2) {
-  const indexAt = await stat2(join4(bundlePath2, SEARCH_INDEX_FILE)).then((s) => s.mtimeMs).catch(() => 0);
+  const indexAt = await stat2(join6(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(
@@ -3964,7 +4750,7 @@ async function isStale(bundlePath2) {
   let stale = false;
   await mapLimit(names, DEFAULT_IO_CONCURRENCY, async (name) => {
     if (stale) return;
-    const at = await stat2(join4(bundlePath2, name)).then((s) => s.mtimeMs).catch(() => 0);
+    const at = await stat2(join6(bundlePath2, name)).then((s) => s.mtimeMs).catch(() => 0);
     if (at > indexAt) stale = true;
   });
   return stale;
@@ -3999,18 +4785,49 @@ async function loadQmd(logger) {
 }
 
 // src/kb-store.ts
-import { createHash as createHash2 } from "crypto";
 import {
   appendFile,
   link,
-  mkdir as mkdir3,
+  mkdir as mkdir4,
   readdir,
-  readFile as readFile4,
-  rename,
+  readFile as readFile7,
+  rename as rename2,
   unlink,
-  writeFile as writeFile3
+  writeFile as writeFile4
 } from "fs/promises";
-import { join as join5, resolve as resolve5, sep as sep3 } from "path";
+import { join as join7, resolve as resolve5, sep as sep3 } from "path";
+
+// src/kb-stamp.ts
+import { createHash as createHash4 } from "crypto";
+function sha2563(contents) {
+  return createHash4("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/kb-links/inbound.ts
 function inboundIndex(bundle) {
@@ -4172,7 +4989,7 @@ function appendUnionMergeLine(contents) {
 }
 
 // src/kb-store.ts
-var KB_DIR = join5(".strauss", "kb");
+var KB_DIR = join7(".strauss", "kb");
 var STORE_OWNED = /* @__PURE__ */ new Set([INDEX_FILE, LOG_FILE, SEARCH_INDEX_FILE]);
 var DEFAULT_LOAD_BUDGET = 25e3;
 var KbStore = class {
@@ -4203,7 +5020,7 @@ var KbStore = class {
     const conceptId2 = `${input.type}.${input.slug}`;
     const root = this.root(bundlePath2);
     const target = this.recordPath(bundlePath2, conceptId2);
-    await mkdir3(root, { recursive: true });
+    await mkdir4(root, { recursive: true });
     await this.publish(
       target,
       stringifyMarkdownWithFrontmatter(input.body, frontmatter),
@@ -4242,7 +5059,7 @@ var KbStore = class {
     const target = this.recordPath(bundlePath2, conceptId2);
     let raw;
     try {
-      raw = await readFile4(target, "utf8");
+      raw = await readFile7(target, "utf8");
     } catch {
       return null;
     }
@@ -4267,7 +5084,7 @@ var KbStore = class {
     const records = await mapLimit(
       wanted,
       DEFAULT_IO_CONCURRENCY,
-      async ({ name, conceptId: conceptId2 }) => this.parse(conceptId2, await readFile4(join5(root, name), "utf8"))
+      async ({ name, conceptId: conceptId2 }) => this.parse(conceptId2, await readFile7(join7(root, name), "utf8"))
     );
     return records.filter((record) => record !== null);
   }
@@ -4424,7 +5241,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
@@ -4542,6 +5359,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);
@@ -4572,11 +5411,11 @@ ${answer}
   async readIndex(bundlePath2) {
     const root = this.root(bundlePath2);
     const expected = renderIndex(await this.list(bundlePath2));
-    const stored = await readFile4(join5(root, INDEX_FILE), "utf8").catch(
+    const stored = await readFile7(join7(root, INDEX_FILE), "utf8").catch(
       () => null
     );
     if (indexIsStale(stored, expected)) {
-      await this.publish(join5(root, INDEX_FILE), expected, true, INDEX_FILE);
+      await this.publish(join7(root, INDEX_FILE), expected, true, INDEX_FILE);
       this.logger.info?.({
         operation: "kb.index.repair",
         bundlePath: root,
@@ -4593,8 +5432,8 @@ ${answer}
    * knows which agent touched what. So a bad line is surfaced and left alone.
    */
   async readLog(bundlePath2) {
-    const raw = await readFile4(
-      join5(this.root(bundlePath2), LOG_FILE),
+    const raw = await readFile7(
+      join7(this.root(bundlePath2), LOG_FILE),
       "utf8"
     ).catch(() => "");
     const result = parseLog(raw);
@@ -4645,15 +5484,15 @@ ${answer}
   }
   async mutate(bundlePath2, conceptId2, change, entry, changeBody = (body) => body) {
     const target = this.recordPath(bundlePath2, conceptId2);
-    const before = await readFile4(target, "utf8").catch(() => null);
+    const before = await readFile7(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 readFile4(target, "utf8").catch(() => null);
-    if (witness === null || digest(witness) !== digest(before)) {
+    const witness = await readFile7(target, "utf8").catch(() => null);
+    if (witness === null || sha2563(witness) !== sha2563(before)) {
       throw new KbWriteConflictError(conceptId2);
     }
     await this.publish(target, contents, true, conceptId2);
@@ -4678,10 +5517,10 @@ ${answer}
    */
   async publish(target, contents, overwrite, conceptId2) {
     const staging = `${target}.${process.pid}.tmp`;
-    await writeFile3(staging, contents, "utf8");
+    await writeFile4(staging, contents, "utf8");
     try {
       if (overwrite) {
-        await rename(staging, target);
+        await rename2(staging, target);
         return;
       }
       await link(staging, target);
@@ -4735,18 +5574,18 @@ ${answer}
    * file must not fail the mutation it guards.
    */
   async ensureGitattributes(root) {
-    const target = join5(root, GITATTRIBUTES_FILE);
+    const target = join7(root, GITATTRIBUTES_FILE);
     try {
       let existing;
       try {
-        existing = await readFile4(target, "utf8");
+        existing = await readFile7(target, "utf8");
       } catch (error) {
         if (error.code !== "ENOENT") throw error;
         existing = null;
       }
       if (existing === null) {
         try {
-          await writeFile3(target, appendUnionMergeLine(""), {
+          await writeFile4(target, appendUnionMergeLine(""), {
             encoding: "utf8",
             flag: "wx"
           });
@@ -4786,7 +5625,7 @@ ${answer}
   async record(root, entry) {
     await this.ensureGitattributes(root);
     const line = renderLogEntry({ at: (/* @__PURE__ */ new Date()).toISOString(), ...entry });
-    await appendFile(join5(root, LOG_FILE), line, "utf8").catch((error) => {
+    await appendFile(join7(root, LOG_FILE), line, "utf8").catch((error) => {
       this.logger.warn?.({
         operation: "kb.log.append",
         outcome: "failed",
@@ -4823,7 +5662,7 @@ ${answer}
         { conceptId: conceptId2 }
       );
     }
-    return join5(this.root(bundlePath2), `${conceptId2}.md`);
+    return join7(this.root(bundlePath2), `${conceptId2}.md`);
   }
 };
 function estimateTokens(record) {
@@ -4850,7 +5689,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)
@@ -4861,25 +5700,6 @@ function normalizeActor(id) {
   if (colon === -1) return id.toLowerCase();
   return id.slice(0, colon + 1).toLowerCase() + id.slice(colon + 1);
 }
-function digest(contents) {
-  return createHash2("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/pack.ts
 var DEFAULT_PACK_HOPS = 2;
@@ -4961,12 +5781,12 @@ 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/version.ts
-var VERSION = true ? "0.1.15" : "0.0.0-dev";
+var VERSION = true ? "0.1.17" : "0.0.0-dev";
 
 export {
   kbSourceSchema,
@@ -5002,9 +5822,19 @@ export {
   repoCacheDir,
   readRemoteAnchors,
   anchorFilePath,
+  grammarsCacheRoot,
+  grammarManifest,
+  ensureGrammar,
+  grammarHints,
+  languageForFile,
+  treeSitterLanguages,
+  TreeSitterResolver,
   regexResolver,
   hashAnchorText,
   resolveAnchor,
+  resolveAnchorSpan,
+  prepareResolvers,
+  defaultAnchorResolvers,
   detectAnchorDrift,
   Fault,
   ErrorTypes,
@@ -5082,4 +5912,4 @@ export {
   KbStore,
   VERSION
 };
-//# sourceMappingURL=chunk-KNIUBCZY.js.map
+//# sourceMappingURL=chunk-ZKIQOBHT.js.map