@saasontools/strauss-kb 0.1.16 → 0.1.18

package/dist/mcp-main.cjs

@@ -23,6 +23,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// ../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.26_supports-color@8.1.1_typescript@6.0.3_yaml@2.9.0/node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
 // src/mcp.ts
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
@@ -75,10 +79,24 @@ var kbAnchorSchema = import_zod.z.object({
   hash: import_zod.z.string().regex(/^sha256:[0-9a-f]{64}$/, {
     message: "hash must be sha256:<64 hex chars>"
   }).optional(),
+  /**
+   * What `hash` was taken over: the span's raw text, or the normalised token
+   * stream a parser sees (`ast`). Absent means `raw`, which is what every
+   * anchor stamped before this field carries, so old hashes keep comparing
+   * the way they were written. An `ast` hash is blind to whitespace and
+   * comments, so reformatting the anchored code is not drift.
+   */
+  hash_kind: import_zod.z.enum(["raw", "ast"]).optional(),
   /** ISO 8601 timestamp of the last successful resolution. */
   resolved_at: import_zod.z.string().min(1).optional(),
   /** Line count of the text the hash was taken over. */
-  lines: import_zod.z.number().int().positive().optional()
+  lines: import_zod.z.number().int().positive().optional(),
+  /**
+   * Which resolver produced the hashed span. Absent means an anchor stamped
+   * before resolvers were named, which is read as `regex` — the only one
+   * there was. A hash from a different resolver is drift, not a match.
+   */
+  resolver: import_zod.z.enum(["tree-sitter", "regex"]).optional()
 }).strict();
 var kbLinkSchema = import_zod.z.object({
   target: import_zod.z.string().min(1),
@@ -442,7 +460,7 @@ function composeNoDecisionRecord(reason, writtenBy, writtenAt) {
 }
 
 // src/commands/anchor-resolve.ts
-var import_zod6 = require("zod");
+var import_zod7 = require("zod");
 
 // src/concurrency.ts
 var DEFAULT_IO_CONCURRENCY = 16;
@@ -459,9 +477,9 @@ async function mapLimit(items, limit, fn) {
     { length: Math.min(limit, items.length) },
     async () => {
       while (!failed && next < items.length) {
-        const at = next++;
+        const at2 = next++;
         try {
-          out[at] = await fn(items[at], at);
+          out[at2] = await fn(items[at2], at2);
         } catch (error) {
           failed = true;
           throw error;
@@ -577,8 +595,8 @@ function safeSegment(value) {
 function revRef(rev) {
   const safe = rev.replace(/[^A-Za-z0-9_-]/g, "-").slice(0, 64);
   let hash = 5381;
-  for (let at = 0; at < rev.length; at++) {
-    hash = (hash * 33 ^ rev.charCodeAt(at)) >>> 0;
+  for (let at2 = 0; at2 < rev.length; at2++) {
+    hash = (hash * 33 ^ rev.charCodeAt(at2)) >>> 0;
   }
   return `refs/strauss/${safe}-${hash.toString(16)}`;
 }
@@ -687,8 +705,8 @@ function repoUrlIsSafe(repo) {
   if (!scheme?.[1]) return false;
   if (!allowed.includes(scheme[1].toLowerCase())) return false;
   const authority = url.slice(scheme[0].length).split("/")[0] ?? "";
-  const at = authority.lastIndexOf("@");
-  return at < 0 || !authority.slice(0, at).includes(":");
+  const at2 = authority.lastIndexOf("@");
+  return at2 < 0 || !authority.slice(0, at2).includes(":");
 }
 function protocolArgs() {
   const allowed = allowedProtocols();
@@ -739,18 +757,18 @@ async function readOneRepo(repo, url, declared, context) {
   if (!repoUrlIsSafe(url)) return all({ ok: false, reason: "repo-invalid" });
   const cache = cachePathFor(repo, context.cacheDir);
   if (!cache) return all({ ok: false, reason: "remote-unreachable" });
-  const rejected = /* @__PURE__ */ new Map();
+  const rejected2 = /* @__PURE__ */ new Map();
   const usable = [];
   for (const want of wants) {
     const reason = wantReason(want);
     if (reason)
-      rejected.set(wantKey(repo, want.ref, want.file), { ok: false, reason });
+      rejected2.set(wantKey(repo, want.ref, want.file), { ok: false, reason });
     else usable.push(want);
   }
-  if (!usable.length) return rejected;
+  if (!usable.length) return rejected2;
   wants = usable;
   const opened = await openCache(cache, url, context);
-  if (opened) return new Map([...rejected, ...all(opened)]);
+  if (opened) return new Map([...rejected2, ...all(opened)]);
   const wantsDefault = wants.some((want) => want.ref === void 0);
   const branch = wantsDefault ? await defaultBranch(cache, context) : {};
   const revs = /* @__PURE__ */ new Map();
@@ -777,9 +795,9 @@ async function readOneRepo(repo, url, declared, context) {
     }
   );
   return new Map([
-    ...rejected,
+    ...rejected2,
     ...wants.map(
-      (want, at) => [wantKey(repo, want.ref, want.file), reads[at]]
+      (want, at2) => [wantKey(repo, want.ref, want.file), reads[at2]]
     )
   ]);
 }
@@ -829,13 +847,13 @@ async function defaultBranch(cache, context) {
     if (!listed.ok) {
       const reason = transportReason(listed.stderr);
       if (reason !== "ref-not-found") {
-        const cached2 = await cachedBranch(cache);
-        return cached2 ? { name: cached2 } : { reason };
+        const cached3 = await cachedBranch(cache);
+        return cached3 ? { name: cached3 } : { reason };
       }
     }
   }
-  const cached = await cachedBranch(cache);
-  if (cached) return { name: cached };
+  const cached2 = await cachedBranch(cache);
+  if (cached2) return { name: cached2 };
   return {
     reason: context.offline ? "remote-unreachable" : "default-branch-unknown"
   };
@@ -862,8 +880,8 @@ async function ensureRev(cache, rev, context) {
       cwd: cache
     }
   );
-  const cached = have.ok && have.stdout.trim().length > 0;
-  if (cached && (context.offline || IMMUTABLE_REV.test(rev))) return void 0;
+  const cached2 = have.ok && have.stdout.trim().length > 0;
+  if (cached2 && (context.offline || IMMUTABLE_REV.test(rev))) return void 0;
   if (context.offline) return { ok: false, reason: "remote-unreachable" };
   const fetched = await git(
     [
@@ -879,7 +897,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 });
@@ -990,67 +1008,655 @@ async function readAnchorFiles(files, read, concurrency = DEFAULT_IO_CONCURRENCY
       return { ok: false, reason: "file-unreadable" };
     }
   });
-  return new Map(wanted.map((file, at) => [file, results[at]]));
+  return new Map(wanted.map((file, at2) => [file, results[at2]]));
 }
 
 // src/anchor-resolver/resolver.ts
+var import_node_crypto3 = require("crypto");
+
+// src/tree-sitter-resolver/languages.ts
+var import_node_path5 = require("path");
+
+// src/grammars/index.ts
+var import_promises4 = require("fs/promises");
+
+// src/grammars/store.ts
 var import_node_crypto = require("crypto");
+var import_promises3 = require("fs/promises");
+var import_node_os2 = require("os");
+var import_node_path3 = require("path");
+function grammarsCacheRoot(override) {
+  return override ?? process.env["STRAUSS_KB_GRAMMARS_DIR"] ?? (0, import_node_path3.join)((0, import_node_os2.homedir)(), ".strauss", "grammars");
+}
+function grammarCachePath(root, language, sha2564, extension = "wasm") {
+  return (0, import_node_path3.join)(root, language, `${sha2564.slice(0, 12)}.${extension}`);
+}
+function sha256(bytes) {
+  return (0, import_node_crypto.createHash)("sha256").update(bytes).digest("hex");
+}
+function matches(bytes, entry) {
+  if (entry.bytes !== void 0 && bytes.byteLength !== entry.bytes)
+    return false;
+  return sha256(bytes) === entry.sha256;
+}
+async function verifyCached(path, entry) {
+  let bytes;
+  try {
+    bytes = await (0, import_promises3.readFile)(path);
+  } catch {
+    return false;
+  }
+  if (matches(bytes, entry)) return true;
+  await (0, import_promises3.rm)(path, { force: true });
+  return false;
+}
+async function writeCached(path, bytes) {
+  await (0, import_promises3.mkdir)((0, import_node_path3.dirname)(path), { recursive: true });
+  const temporary = `${path}.${process.pid}.${(0, import_node_crypto.randomBytes)(4).toString("hex")}.tmp`;
+  try {
+    await (0, import_promises3.writeFile)(temporary, bytes);
+    await (0, import_promises3.rename)(temporary, path);
+  } catch (error) {
+    await (0, import_promises3.rm)(temporary, { force: true });
+    throw error;
+  }
+}
+
+// src/grammars/fetch.ts
+var ATTEMPTS = 3;
+var BACKOFF_MS = 250;
+function grammarUrl(url, override) {
+  const base2 = grammarsBaseUrl(override);
+  if (!base2) return url;
+  let root = base2;
+  while (root.endsWith("/")) root = root.slice(0, -1);
+  const pinned = new URL(url);
+  return `${root}${pinned.pathname}${pinned.search}`;
+}
+function grammarsBaseUrl(override) {
+  return override ?? process.env["STRAUSS_KB_GRAMMARS_URL"];
+}
+async function downloadPart(url, name, entry, options = {}) {
+  const log = options.log ?? ((line) => void process.stderr.write(line));
+  const weight = entry.bytes === void 0 ? "" : ` (${size(entry.bytes)} from manifest)`;
+  log(`strauss-kb: downloading ${name}${weight} from ${url}
+`);
+  let cause = "";
+  for (let attempt = 1; attempt <= ATTEMPTS; attempt++) {
+    const outcome = await attemptDownload(url, entry, options.fetchTimeoutMs);
+    if ("bytes" in outcome) return outcome;
+    cause = outcome.cause;
+    log(
+      `strauss-kb: ${name} attempt ${attempt}/${ATTEMPTS} failed: ${cause}
+`
+    );
+    if (!outcome.retry) break;
+    if (attempt < ATTEMPTS) await pause(BACKOFF_MS * attempt);
+  }
+  log(`strauss-kb: ${name} not downloaded: ${cause}
+`);
+  return { cause };
+}
+async function attemptDownload(url, entry, timeoutMs) {
+  try {
+    const response = await fetch(url, {
+      signal: AbortSignal.timeout(fetchTimeoutMs(timeoutMs))
+    });
+    if (!response.ok) {
+      return {
+        cause: `HTTP ${response.status}`,
+        retry: response.status >= 500 || response.status === 429
+      };
+    }
+    const bytes = new Uint8Array(await response.arrayBuffer());
+    if (!matches(bytes, entry))
+      return { cause: "sha256 mismatch", retry: false };
+    return { bytes };
+  } catch (error) {
+    const timedOut = error instanceof Error && (error.name === "TimeoutError" || error.name === "AbortError");
+    return { cause: timedOut ? "timeout" : "network error", retry: true };
+  }
+}
+function size(bytes) {
+  return bytes >= 1024 * 1024 ? `${(bytes / (1024 * 1024)).toFixed(1)} MB` : `${Math.round(bytes / 1024)} KB`;
+}
+function pause(ms) {
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
+}
+
+// src/grammars/manifest.ts
+var import_node_fs = require("fs");
+var import_node_path4 = require("path");
+var import_node_url = require("url");
+
+// src/grammars/model.ts
+var import_zod4 = require("zod");
+var sha2562 = import_zod4.z.string().regex(/^[0-9a-f]{64}$/);
+var grammarWasmSchema = import_zod4.z.object({
+  url: import_zod4.z.string().min(1),
+  sha256: sha2562,
+  bytes: import_zod4.z.number().int().positive()
+});
+var grammarTagsSchema = import_zod4.z.object({ url: import_zod4.z.string().min(1), sha256: sha2562 });
+var grammarPackSchema = import_zod4.z.object({
+  package: import_zod4.z.string().min(1),
+  wasm: grammarWasmSchema,
+  tags: import_zod4.z.array(grammarTagsSchema),
+  license: import_zod4.z.string().min(1),
+  extensions: import_zod4.z.array(import_zod4.z.string().min(1))
+});
+var grammarManifestSchema = import_zod4.z.object({
+  /** The runtime the packs were proved against. */
+  webTreeSitter: import_zod4.z.string().min(1),
+  linguist: import_zod4.z.object({ tag: import_zod4.z.string().min(1), commit: import_zod4.z.string().min(1) }),
+  packs: import_zod4.z.record(import_zod4.z.string().min(1), grammarPackSchema)
+});
+
+// src/grammars/manifest.ts
+var cached;
+function grammarManifest() {
+  cached ??= grammarManifestSchema.parse(
+    JSON.parse((0, import_node_fs.readFileSync)(grammarsDataPath("manifest.json"), "utf8"))
+  );
+  return cached;
+}
+function grammarsDataPath(...segments) {
+  let dir = (0, import_node_path4.dirname)((0, import_node_url.fileURLToPath)(importMetaUrl));
+  for (let up = 0; up < 5; up++) {
+    const candidate = (0, import_node_path4.join)(dir, "grammars");
+    if ((0, import_node_fs.existsSync)((0, import_node_path4.join)(candidate, "manifest.json")))
+      return (0, import_node_path4.join)(candidate, ...segments);
+    dir = (0, import_node_path4.dirname)(dir);
+  }
+  throw new Error("grammars/manifest.json is missing from the package");
+}
+
+// src/grammars/index.ts
+var inFlight = /* @__PURE__ */ new Map();
+var missing = /* @__PURE__ */ new Map();
+var uncompilable = /* @__PURE__ */ new Map();
+var rejected = /* @__PURE__ */ new Map();
+function grammarsDownloadDisabled() {
+  return process.env["STRAUSS_KB_GRAMMARS"] === "off";
+}
+async function ensureGrammar(language, options = {}) {
+  const pack2 = grammarManifest().packs[language];
+  if (!pack2) return null;
+  const root = grammarsCacheRoot(options.cacheRoot);
+  const wasm = grammarCachePath(root, language, pack2.wasm.sha256);
+  const key = `${wasm} ${grammarsBaseUrl(options.baseUrl) ?? ""}`;
+  const existing = inFlight.get(key);
+  if (existing) return existing;
+  const pending = (async () => {
+    const grammar = await ensurePart(
+      wasm,
+      `tree-sitter-${language}`,
+      pack2.wasm,
+      options
+    );
+    if (grammar !== true)
+      return miss(language, `grammar tree-sitter-${language}`, grammar);
+    const parts = [];
+    const total = pack2.tags.length;
+    for (const [at2, part] of pack2.tags.entries()) {
+      const name = `${language} tags${total > 1 ? ` part ${at2 + 1}/${total}` : ""}`;
+      const path = grammarCachePath(root, language, part.sha256, "scm");
+      const held = await ensurePart(path, name, part, options);
+      if (held !== true) return miss(language, name, held);
+      parts.push(`; ${part.url}
+${lf(await (0, import_promises4.readFile)(path, "utf8"))}`);
+    }
+    missing.delete(language);
+    return { wasm, query: total ? parts.join("\n") : void 0 };
+  })();
+  inFlight.set(key, pending);
+  const result = await pending;
+  if (result === null) inFlight.delete(key);
+  return result;
+}
+async function ensurePart(path, name, entry, options) {
+  if (await verifyCached(path, entry)) return true;
+  if (options.offline === true || grammarsDownloadDisabled()) return {};
+  const download = await downloadPart(
+    grammarUrl(entry.url, options.baseUrl),
+    name,
+    entry,
+    options
+  );
+  if ("cause" in download) return { cause: download.cause };
+  await writeCached(path, download.bytes).catch(() => null);
+  return true;
+}
+function miss(language, subject, failure) {
+  missing.set(language, { subject, ...failure });
+  return null;
+}
+function lf(body) {
+  return body.replace(/\r\n/g, "\n");
+}
+function noteUncompilableQuery(language, cause) {
+  uncompilable.set(language, cause);
+}
+function noteRejectedGrammar(language, cause) {
+  rejected.set(language, cause);
+}
+function grammarHints() {
+  const manifest = grammarManifest();
+  const packs = manifest.packs;
+  const lines = /* @__PURE__ */ new Map();
+  for (const [language, { subject, cause }] of missing)
+    lines.set(
+      language,
+      `${subject} not cached${cause ? ` (${cause})` : ""}; run online once, or set STRAUSS_KB_GRAMMARS_DIR`
+    );
+  for (const [language, cause] of rejected)
+    lines.set(
+      language,
+      `${packs[language]?.package ?? `tree-sitter-${language}`} rejected by web-tree-sitter ${manifest.webTreeSitter}${cause ? `: ${cause}` : ""}; re-pin with pnpm grammars pin ${language}`
+    );
+  for (const [language, cause] of uncompilable)
+    lines.set(
+      language,
+      `tags query for ${language} does not compile against ${packs[language]?.package ?? `tree-sitter-${language}`}: ${cause}; re-pin with pnpm grammars pin ${language}`
+    );
+  return [...lines].sort(([a], [b]) => a.localeCompare(b)).map(([, line]) => line);
+}
+
+// src/tree-sitter-resolver/languages.ts
+var table;
+function extensionTable() {
+  const manifest = grammarManifest();
+  if (table?.of !== manifest)
+    table = {
+      of: manifest,
+      extensions: Object.fromEntries(
+        Object.entries(manifest.packs).flatMap(
+          ([language, pack2]) => pack2.extensions.map((extension) => [extension, language])
+        )
+      )
+    };
+  return table.extensions;
+}
+function hasQuery(language) {
+  return (grammarManifest().packs[language]?.tags.length ?? 0) > 0;
+}
+function languageForFile(file) {
+  const language = extensionTable()[(0, import_node_path5.extname)(file).toLowerCase()];
+  return language && hasQuery(language) ? language : void 0;
+}
+
+// src/tree-sitter-resolver/resolver.ts
+var import_node_crypto2 = require("crypto");
+var import_web_tree_sitter = require("web-tree-sitter");
+
+// src/tree-sitter-resolver/definitions.ts
+var SCOPE_ONLY = "reference.implementation";
+function index(tree, query) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const match of query.matches(tree.rootNode)) {
+    const nameNode = match.captures.find((capture) => capture.name === "name");
+    const defNode = match.captures.find(
+      (capture) => capture.name.startsWith("definition.") || capture.name === SCOPE_ONLY
+    );
+    if (!nameNode || !defNode) continue;
+    const candidate = {
+      node: defNode.node,
+      name: nameNode.node.text,
+      target: defNode.name !== SCOPE_ONLY
+    };
+    const existing = byName.get(nameNode.node.id);
+    if (existing && width(existing.node) <= width(candidate.node)) continue;
+    byName.set(nameNode.node.id, candidate);
+  }
+  const definitions = [...byName.values()];
+  return {
+    tree,
+    byNodeId: new Map(
+      definitions.map((definition) => [definition.node.id, definition])
+    ),
+    definitions
+  };
+}
+function select(parsed, wanted) {
+  const matches3 = parsed.definitions.filter(
+    (definition) => definition.target && endsWith(chainOf(definition, parsed.byNodeId), wanted)
+  );
+  if (matches3.length < 2) return matches3;
+  const bodied = matches3.filter(
+    (definition) => definition.node.childForFieldName("body") !== null
+  );
+  return bodied.length === 1 ? bodied : matches3;
+}
+function chainOf(definition, byNodeId) {
+  const chain = [definition.name];
+  const receiver = definition.node.childForFieldName("receiver");
+  const type = receiver && typeNameIn(receiver);
+  if (type) chain.unshift(type);
+  for (let node = definition.node.parent; node; node = node.parent) {
+    const enclosing = byNodeId.get(node.id);
+    if (enclosing && enclosing.node !== definition.node)
+      chain.unshift(enclosing.name);
+  }
+  return chain;
+}
+function typeNameIn(receiver) {
+  const stack = [receiver];
+  while (stack.length) {
+    const node = stack.pop();
+    if (node.type === "type_identifier") return node.text;
+    for (let at2 = 0; at2 < node.childCount; at2++) {
+      const child = node.child(at2);
+      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, at2) => chain[offset + at2] === 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/tokens.ts
+function tokens(root) {
+  const out = [];
+  const stack = [root];
+  while (stack.length) {
+    const node = stack.pop();
+    if (node.type.includes("comment")) continue;
+    if (node.childCount === 0) {
+      const text = node.text.trim();
+      if (text) out.push(text);
+      continue;
+    }
+    for (let at2 = node.childCount - 1; at2 >= 0; at2--) {
+      const child = node.child(at2);
+      if (child) stack.push(child);
+    }
+  }
+  return out;
+}
+
+// src/tree-sitter-resolver/resolver.ts
+var TREE_CACHE_LIMIT = 32;
+var TreeSitterResolver = class {
+  name = "tree-sitter";
+  grammars;
+  loaded = /* @__PURE__ */ new Map();
+  trees = /* @__PURE__ */ new Map();
+  parser;
+  initialized = false;
+  /** Cache effectiveness, for tests and for the latency numbers. */
+  stats = { parses: 0, cacheHits: 0 };
+  constructor(options = {}) {
+    this.grammars = options;
+  }
+  /**
+   * Loads the grammars these files need, once per language per process,
+   * downloading each one on first use.
+   *
+   * A grammar that will not load is remembered as unavailable rather than
+   * retried per anchor, and never throws: an unobtainable WASM is a finding.
+   */
+  async prepare(files) {
+    const wanted = /* @__PURE__ */ new Set();
+    for (const file of files) {
+      const language = languageForFile(file);
+      if (language && !this.loaded.has(language)) wanted.add(language);
+    }
+    if (!wanted.size) return;
+    if (!this.initialized) {
+      try {
+        await import_web_tree_sitter.Parser.init();
+        this.parser = new import_web_tree_sitter.Parser();
+        this.initialized = true;
+      } catch {
+        for (const language of wanted) this.loaded.set(language, null);
+        return;
+      }
+    }
+    const languages = [...wanted];
+    const loaded = await mapLimit(
+      languages,
+      Math.min(DEFAULT_IO_CONCURRENCY, languages.length),
+      (language) => this.load(language)
+    );
+    languages.forEach(
+      (language, at2) => this.loaded.set(language, loaded[at2] ?? null)
+    );
+  }
+  /**
+   * An unobtainable grammar, one this runtime refuses, and a query that will
+   * not compile are three faults with three repairs; all are reported through
+   * the grammars module so every hint has one home.
+   */
+  async load(language) {
+    let pack2;
+    try {
+      pack2 = await ensureGrammar(language, this.grammars);
+    } catch {
+      return null;
+    }
+    if (!pack2?.query) return null;
+    let grammar;
+    try {
+      grammar = await import_web_tree_sitter.Language.load(pack2.wasm);
+    } catch (error) {
+      noteRejectedGrammar(language, why(error));
+      return null;
+    }
+    try {
+      return { language: grammar, query: new import_web_tree_sitter.Query(grammar, pack2.query) };
+    } catch (error) {
+      noteUncompilableQuery(language, why(error));
+      return null;
+    }
+  }
+  /**
+   * Abstains on an extension with no grammar so the regex resolver gets a
+   * turn; reports `resolver-unavailable` when the grammar exists in principle
+   * but could not be loaded, because falling back there would silently trade a
+   * precise span for a guessed one.
+   */
+  attempt(source, symbol, file) {
+    const language = file ? languageForFile(file) : void 0;
+    if (!language) return { kind: "abstain" };
+    if (!this.loaded.has(language)) return { kind: "abstain" };
+    const loaded = this.loaded.get(language);
+    if (!loaded) return { kind: "unresolved", reason: "resolver-unavailable" };
+    const parsed = this.parse(language, loaded, source);
+    if (!parsed) return { kind: "unresolved", reason: "resolver-unavailable" };
+    const wanted = symbol.split(".").filter(Boolean);
+    if (!wanted.length)
+      return { kind: "unresolved", reason: "symbol-not-found" };
+    const matches3 = select(parsed, wanted);
+    if (!matches3.length)
+      return { kind: "unresolved", reason: "symbol-not-found" };
+    if (matches3.length > 1)
+      return { kind: "unresolved", reason: "symbol-ambiguous" };
+    return { kind: "resolved", span: spanOf(matches3[0], source) };
+  }
+  resolve(source, symbol, file) {
+    const attempt = this.attempt(source, symbol, file);
+    return attempt.kind === "resolved" ? attempt.span : null;
+  }
+  /** Parsed trees are keyed by content hash, so an unchanged file parses once. */
+  parse(language, loaded, source) {
+    const key = `${language}:${(0, import_node_crypto2.createHash)("sha256").update(source).digest("hex")}`;
+    const cached2 = this.trees.get(key);
+    if (cached2) {
+      this.stats.cacheHits += 1;
+      return cached2;
+    }
+    const parser = this.parser;
+    if (!parser) return null;
+    let parsed;
+    try {
+      parser.setLanguage(loaded.language);
+      const tree = parser.parse(source);
+      if (!tree) return null;
+      parsed = index(tree, loaded.query);
+    } catch {
+      return null;
+    }
+    this.stats.parses += 1;
+    if (this.trees.size >= TREE_CACHE_LIMIT) {
+      const oldest = this.trees.keys().next();
+      if (!oldest.done) {
+        this.trees.get(oldest.value)?.tree.delete();
+        this.trees.delete(oldest.value);
+      }
+    }
+    this.trees.set(key, parsed);
+    return parsed;
+  }
+  /**
+   * Every definition this file declares, as dotted symbol and span.
+   *
+   * The inverse of `attempt`: that asks "where is this name", this asks "what
+   * names are here". `moved` needs the second — the stored hash has to be
+   * looked for at every definition in the repository, and there is no name to
+   * ask about, since the whole question is which name now carries that code.
+   */
+  spans(source, file) {
+    const language = languageForFile(file);
+    if (!language) return [];
+    const loaded = this.loaded.get(language);
+    if (!loaded) return [];
+    const parsed = this.parse(language, loaded, source);
+    if (!parsed) return [];
+    return parsed.definitions.filter((definition) => definition.target).map((definition) => ({
+      symbol: chainOf(definition, parsed.byNodeId).join("."),
+      span: spanOf(definition, source)
+    }));
+  }
+  /**
+   * The token stream of a span: every leaf the parser sees, comments dropped,
+   * joined by single spaces.
+   *
+   * This is what makes a reformat not be drift. Hashing it rather than the raw
+   * text means indentation, line breaks, trailing commas the formatter moved,
+   * and every comment above or inside the definition are outside the hash —
+   * and a renamed identifier or a changed literal is still inside it, because
+   * those are leaves.
+   *
+   * `null` when the file has no grammar, the grammar would not load, or the
+   * text will not parse: no normalisation is better than a guessed one.
+   */
+  normalize(text, file) {
+    const language = file ? languageForFile(file) : void 0;
+    if (!language) return null;
+    const loaded = this.loaded.get(language);
+    if (!loaded) return null;
+    const parser = this.parser;
+    if (!parser) return null;
+    let tree;
+    try {
+      parser.setLanguage(loaded.language);
+      tree = parser.parse(text);
+    } catch {
+      return null;
+    }
+    if (!tree) return null;
+    try {
+      return tokens(tree.rootNode).join(" ");
+    } finally {
+      tree.delete();
+    }
+  }
+  /** Drops cached trees. Grammars stay loaded — they are immutable. */
+  reset() {
+    for (const parsed of this.trees.values()) parsed.tree.delete();
+    this.trees.clear();
+    this.stats.parses = 0;
+    this.stats.cacheHits = 0;
+  }
+};
+function why(error) {
+  const text = error instanceof Error ? error.message : String(error);
+  return text || "no reason given";
+}
+
+// src/anchor-resolver/resolver.ts
 var PARENT_SCOPE_LINES = 50;
 var CLEAN_STATE = { blockComment: false, template: false };
 function stripLine(line, state) {
   let out = "";
-  let index = 0;
+  let index2 = 0;
   let { blockComment, template } = state;
-  while (index < line.length) {
-    const char = line[index];
-    const next = line[index + 1];
+  while (index2 < line.length) {
+    const char = line[index2];
+    const next = line[index2 + 1];
     if (blockComment) {
       if (char === "*" && next === "/") {
         blockComment = false;
-        index += 2;
+        index2 += 2;
         continue;
       }
-      index += 1;
+      index2 += 1;
       continue;
     }
     if (template) {
       if (char === "\\") {
-        index += 2;
+        index2 += 2;
         continue;
       }
       if (char === "`") template = false;
-      index += 1;
+      index2 += 1;
       continue;
     }
     if (char === "/" && next === "*") {
       blockComment = true;
-      index += 2;
+      index2 += 2;
       continue;
     }
     if (char === "/" && next === "/") break;
     if (char === "`") {
       template = true;
-      index += 1;
+      index2 += 1;
       continue;
     }
     if (char === "'" || char === '"') {
       const quote = char;
-      index += 1;
-      while (index < line.length) {
-        if (line[index] === "\\") {
-          index += 2;
+      index2 += 1;
+      while (index2 < line.length) {
+        if (line[index2] === "\\") {
+          index2 += 2;
           continue;
         }
-        if (line[index] === quote) {
-          index += 1;
+        if (line[index2] === quote) {
+          index2 += 1;
           break;
         }
-        index += 1;
+        index2 += 1;
       }
       continue;
     }
     out += char;
-    index += 1;
+    index2 += 1;
   }
   return { code: out, state: { blockComment, template } };
 }
@@ -1065,8 +1671,8 @@ function captureBraceBlock(lines, matchLine) {
   let depth = 0;
   let opened = false;
   let state = CLEAN_STATE;
-  for (let index = matchLine; index < lines.length; index++) {
-    const stripped = stripLine(lines[index] ?? "", state);
+  for (let index2 = matchLine; index2 < lines.length; index2++) {
+    const stripped = stripLine(lines[index2] ?? "", state);
     state = stripped.state;
     for (const char of stripped.code) {
       if (char === "{") {
@@ -1075,10 +1681,10 @@ function captureBraceBlock(lines, matchLine) {
       } else if (char === "}") {
         depth = Math.max(0, depth - 1);
       } else if (char === ";" && !opened) {
-        return span(lines, matchLine, index);
+        return span(lines, matchLine, index2);
       }
     }
-    if (opened && depth === 0) return span(lines, matchLine, index);
+    if (opened && depth === 0) return span(lines, matchLine, index2);
   }
   return null;
 }
@@ -1087,22 +1693,22 @@ function captureIndentedBlock(lines, matchLine) {
   const header = lines[matchLine] ?? "";
   const indent = header.length - header.trimStart().length;
   let headerEnd = -1;
-  for (let index = matchLine; index < lines.length && index <= matchLine + 20; index++) {
-    const code = stripLine(lines[index] ?? "", CLEAN_STATE).code.trimEnd();
+  for (let index2 = matchLine; index2 < lines.length && index2 <= matchLine + 20; index2++) {
+    const code = stripLine(lines[index2] ?? "", CLEAN_STATE).code.trimEnd();
     if (code.endsWith(":")) {
-      headerEnd = index;
+      headerEnd = index2;
       break;
     }
-    if (code.includes(":")) return span(lines, matchLine, index);
+    if (code.includes(":")) return span(lines, matchLine, index2);
   }
   if (headerEnd === -1) return null;
   let end = headerEnd;
-  for (let index = headerEnd + 1; index < lines.length; index++) {
-    const line = lines[index] ?? "";
+  for (let index2 = headerEnd + 1; index2 < lines.length; index2++) {
+    const line = lines[index2] ?? "";
     if (line.trim() === "") continue;
     const lineIndent = line.length - line.trimStart().length;
     if (lineIndent <= indent) break;
-    end = index;
+    end = index2;
   }
   return end === headerEnd ? null : span(lines, matchLine, end);
 }
@@ -1126,15 +1732,15 @@ 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)) {
-          candidates = candidates.filter((_, at) => distances[at] === nearest);
+          candidates = candidates.filter((_, at2) => distances[at2] === nearest);
         }
       }
       if (candidates.length !== 1) return null;
@@ -1147,34 +1753,82 @@ 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 at2 = index2; at2 >= floor; at2--) {
+    if (parent.test(lines[at2] ?? "")) return index2 - at2;
   }
   return Number.POSITIVE_INFINITY;
 }
 function hashAnchorText(text) {
-  return `sha256:${(0, import_node_crypto.createHash)("sha256").update(text.replace(/\r\n/g, "\n")).digest("hex")}`;
+  return `sha256:${(0, import_node_crypto3.createHash)("sha256").update(text.replace(/\r\n/g, "\n")).digest("hex")}`;
 }
-function resolveAnchor(source, anchor, resolver = regexResolver) {
+function resolveAnchorSpan(source, anchor, resolvers = [regexResolver]) {
   const normalized = source.replace(/\r\n/g, "\n");
   if (!anchor.symbol) {
     const lines = normalized.split("\n");
     if (lines.length > 1 && lines[lines.length - 1] === "") lines.pop();
     return {
-      text: normalized,
-      startLine: 1,
-      endLine: Math.max(1, lines.length)
+      ok: true,
+      span: {
+        text: normalized,
+        startLine: 1,
+        endLine: Math.max(1, lines.length)
+      }
     };
   }
-  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 };
+    }
+    const tokens2 = resolver.normalize?.(attempt.span.text, anchor.file);
+    return {
+      ok: true,
+      span: attempt.span,
+      ...isResolverName(resolver.name) ? { resolver: resolver.name } : {},
+      ...tokens2 ? { normalized: tokens2 } : {}
+    };
+  }
+  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;
+}
+function anchorHashOf(anchor, outcome) {
+  const stored = anchor.hash ? anchor.hash_kind ?? "raw" : void 0;
+  const wanted = stored ?? (outcome.normalized ? "ast" : "raw");
+  return wanted === "ast" && outcome.normalized ? { hash: hashAnchorText(outcome.normalized), kind: "ast" } : { hash: hashAnchorText(outcome.span.text), kind: "raw" };
 }
 
 // src/anchor-resolver/drift.ts
 async function detectAnchorDrift(records, options = {}) {
   const repoRoot = options.repoRoot ?? process.cwd();
-  const resolver = options.resolver ?? regexResolver;
+  const resolvers = options.resolvers ?? (options.resolver ? [options.resolver] : defaultAnchorResolvers({
+    offline: options.remote?.offline === true
+  }));
   const origin = new LazyOrigin(repoRoot);
   const planned = /* @__PURE__ */ new Map();
   let declaresRepo = false;
@@ -1212,12 +1866,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);
@@ -1243,50 +1901,94 @@ function unresolved(anchor, reason, repo) {
     state: "unresolved",
     diffSize: null,
     ...reason ? { reason } : {},
-    ...repo ? { repo } : {}
+    ...repo ? { repo } : {},
+    ...classOf(reason)
   };
 }
-function hashIn(source, anchor, resolver) {
-  const resolved = resolveAnchor(source, anchor, resolver);
-  if (!resolved) return null;
+function provisionalDriftClass(entry) {
+  if (entry.state === "unresolved") {
+    return entry.reason === "file-missing" || entry.reason === "symbol-not-found" ? "gone" : void 0;
+  }
+  return entry.state === "drifted" ? "changed" : void 0;
+}
+function classOf(reason) {
+  const settled = provisionalDriftClass({ state: "unresolved", reason });
+  return settled ? { class: settled } : {};
+}
+function hashIn(source, anchor, resolvers) {
+  const outcome = resolveAnchorSpan(source, anchor, resolvers);
+  if (!outcome.ok) return { ok: false, reason: outcome.reason };
+  const { hash, kind } = anchorHashOf(anchor, outcome);
   return {
-    hash: hashAnchorText(resolved.text),
-    lines: resolved.endLine - resolved.startLine + 1
+    ok: true,
+    current: {
+      hash,
+      kind,
+      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 = {}) {
+  const matched = current.hash === anchor.hash;
   return {
     ...base(anchor),
-    state: current.hash === anchor.hash ? "match" : "drifted",
+    state: matched ? "match" : "drifted",
     currentHash: current.hash,
+    hashKind: current.kind,
     diffSize: anchor.lines === void 0 ? null : Math.abs(current.lines - anchor.lines),
+    ...matched ? {} : { class: "changed" },
     ...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
@@ -1474,9 +2176,9 @@ var KbStampDigestBaselineError = class extends BaseError {
 // 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);
@@ -1487,9 +2189,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]) : {}
@@ -1520,23 +2222,23 @@ var KbBaseFrozenError = class extends Error {
 };
 
 // src/kb-pins/frozen.ts
-var import_node_path5 = require("path");
+var import_node_path8 = require("path");
 
 // src/kb-pins/layers.ts
-var import_promises3 = require("fs/promises");
-var import_node_os2 = require("os");
-var import_node_path4 = require("path");
+var import_promises5 = require("fs/promises");
+var import_node_os3 = require("os");
+var import_node_path7 = require("path");
 
 // src/kb-pins/model.ts
-var import_node_path3 = require("path");
-var import_zod4 = require("zod");
-var PINS_FILE = (0, import_node_path3.join)(".strauss", "kb-pins.json");
-var PINS_LOCAL_FILE = (0, import_node_path3.join)(".strauss", "kb-pins.local.json");
+var import_node_path6 = require("path");
+var import_zod5 = require("zod");
+var PINS_FILE = (0, import_node_path6.join)(".strauss", "kb-pins.json");
+var PINS_LOCAL_FILE = (0, import_node_path6.join)(".strauss", "kb-pins.local.json");
 var PIN_LAYERS = ["project", "local", "user"];
-var pinSchema = import_zod4.z.object({
+var pinSchema = import_zod5.z.object({
   /** Relative to the manifest's root, so the file is committable. */
-  path: import_zod4.z.string().min(1),
-  pinnedAt: import_zod4.z.string().min(1).optional(),
+  path: import_zod5.z.string().min(1),
+  pinnedAt: import_zod5.z.string().min(1).optional(),
   /**
    * How `context` renders this base. `full` preloads the whole base into
    * the block regardless of the full-under threshold — for a base whose
@@ -1546,7 +2248,7 @@ var pinSchema = import_zod4.z.object({
    * Absent: the profile's full-under threshold decides. Invalid values
    * degrade to absent rather than failing the manifest.
    */
-  mode: import_zod4.z.enum(["full", "index"]).optional().catch(void 0),
+  mode: import_zod5.z.enum(["full", "index"]).optional().catch(void 0),
   /**
    * Context profiles this pin surfaces in (e.g. only at session-start,
    * not per turn). Absent: every profile. A run without a profile sees
@@ -1554,17 +2256,17 @@ var pinSchema = import_zod4.z.object({
    * that skill at point of use than pinned at all — pins are what every
    * session should see.
    */
-  profiles: import_zod4.z.array(import_zod4.z.string()).optional().catch(void 0),
+  profiles: import_zod5.z.array(import_zod5.z.string()).optional().catch(void 0),
   /**
    * The base is concluded — a finished piece of research, a frozen ADR
    * set. Write commands against it refuse while this workspace holds the
    * pin, and `context` labels it read-only. Workspace policy, not base
    * state: the base itself stays copyable and writable elsewhere.
    */
-  frozen: import_zod4.z.boolean().optional().catch(void 0)
+  frozen: import_zod5.z.boolean().optional().catch(void 0)
 }).passthrough();
-var pinsManifestSchema = import_zod4.z.object({
-  pins: import_zod4.z.array(pinSchema).default([]),
+var pinsManifestSchema = import_zod5.z.object({
+  pins: import_zod5.z.array(pinSchema).default([]),
   /**
    * Per-repo budgets for the `context` command, keyed by profile —
    * `"session-start"`, `"compact"`, `"turn"`, or `"default"` for all of
@@ -1573,18 +2275,18 @@ var pinsManifestSchema = import_zod4.z.object({
    * the index at every session start. `contextProfileBudgets` does the
    * tolerant read.
    */
-  context: import_zod4.z.unknown().optional()
+  context: import_zod5.z.unknown().optional()
 }).passthrough();
 
 // src/kb-pins/layers.ts
 function userRoot() {
-  return process.env.STRAUSS_KB_USER_ROOT || (0, import_node_os2.homedir)();
+  return process.env.STRAUSS_KB_USER_ROOT || (0, import_node_os3.homedir)();
 }
 function layerRoot(workspaceDir, layer) {
-  return layer === "user" ? userRoot() : (0, import_node_path4.resolve)(workspaceDir);
+  return layer === "user" ? userRoot() : (0, import_node_path7.resolve)(workspaceDir);
 }
 function layerFile(workspaceDir, layer) {
-  return (0, import_node_path4.join)(
+  return (0, import_node_path7.join)(
     layerRoot(workspaceDir, layer),
     layer === "local" ? PINS_LOCAL_FILE : PINS_FILE
   );
@@ -1593,7 +2295,7 @@ async function readPinsLayer(workspaceDir, layer) {
   const file = layerFile(workspaceDir, layer);
   let raw;
   try {
-    raw = await (0, import_promises3.readFile)(file, "utf8");
+    raw = await (0, import_promises5.readFile)(file, "utf8");
   } catch {
     return { pins: [] };
   }
@@ -1617,16 +2319,16 @@ async function readPinsLayer(workspaceDir, layer) {
 }
 async function writePinsLayer(workspaceDir, layer, manifest) {
   const file = layerFile(workspaceDir, layer);
-  await (0, import_promises3.mkdir)((0, import_node_path4.dirname)(file), { recursive: true });
-  await (0, import_promises3.writeFile)(file, `${JSON.stringify(manifest, null, 2)}
+  await (0, import_promises5.mkdir)((0, import_node_path7.dirname)(file), { recursive: true });
+  await (0, import_promises5.writeFile)(file, `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
 }
 function resolvePinPath(rootDir, path) {
-  return (0, import_node_path4.isAbsolute)(path) ? (0, import_node_path4.resolve)(path) : (0, import_node_path4.resolve)(rootDir, path.split("/").join(import_node_path4.sep));
+  return (0, import_node_path7.isAbsolute)(path) ? (0, import_node_path7.resolve)(path) : (0, import_node_path7.resolve)(rootDir, path.split("/").join(import_node_path7.sep));
 }
 function storablePath(rootDir, bundlePath2) {
-  const rel = (0, import_node_path4.relative)((0, import_node_path4.resolve)(rootDir), (0, import_node_path4.resolve)(bundlePath2));
-  return (rel === "" ? "." : rel).split(import_node_path4.sep).join("/");
+  const rel = (0, import_node_path7.relative)((0, import_node_path7.resolve)(rootDir), (0, import_node_path7.resolve)(bundlePath2));
+  return (rel === "" ? "." : rel).split(import_node_path7.sep).join("/");
 }
 async function readMergedPins(workspaceDir) {
   const manifests = {};
@@ -1654,7 +2356,7 @@ async function readMergedPins(workspaceDir) {
 // src/kb-pins/frozen.ts
 async function assertBaseNotFrozen(workspaceDir, bundlePath2) {
   const merged = await readMergedPins(workspaceDir);
-  const absolute = (0, import_node_path5.resolve)(bundlePath2);
+  const absolute = (0, import_node_path8.resolve)(bundlePath2);
   const pin = merged.pins.find((entry) => entry.absolutePath === absolute);
   if (pin?.frozen === true) {
     throw new KbBaseFrozenError(pin.path, pin.layer);
@@ -1683,7 +2385,7 @@ async function listPins(store, workspaceDir) {
 }
 
 // src/kb-pins/pin.ts
-async function pinBase(store, workspaceDir, bundlePath2, at, options = {}) {
+async function pinBase(store, workspaceDir, bundlePath2, at2, options = {}) {
   const layer = options.layer ?? "project";
   const root = layerRoot(workspaceDir, layer);
   const manifest = await readPinsLayer(workspaceDir, layer);
@@ -1711,7 +2413,7 @@ async function pinBase(store, workspaceDir, bundlePath2, at, options = {}) {
     return {
       path: existing.path,
       layer,
-      pinnedAt: existing.pinnedAt ?? at,
+      pinnedAt: existing.pinnedAt ?? at2,
       alreadyPinned: true,
       ...updated.mode ? { mode: updated.mode } : {},
       ...updated.profiles ? { profiles: updated.profiles } : {},
@@ -1721,7 +2423,7 @@ async function pinBase(store, workspaceDir, bundlePath2, at, options = {}) {
   }
   const entry = {
     path: storablePath(root, bundlePath2),
-    pinnedAt: at,
+    pinnedAt: at2,
     ...fields
   };
   await writePinsLayer(workspaceDir, layer, {
@@ -1731,7 +2433,7 @@ async function pinBase(store, workspaceDir, bundlePath2, at, options = {}) {
   return {
     path: entry.path,
     layer,
-    pinnedAt: at,
+    pinnedAt: at2,
     alreadyPinned: false,
     ...fields,
     ...warning ? { warning } : {}
@@ -1739,7 +2441,7 @@ async function pinBase(store, workspaceDir, bundlePath2, at, options = {}) {
 }
 
 // src/kb-pins/unpin.ts
-var import_node_path6 = require("path");
+var import_node_path9 = require("path");
 async function unpinBase(workspaceDir, bundlePath2) {
   const layers = [];
   for (const layer of PIN_LAYERS) {
@@ -1760,17 +2462,17 @@ async function unpinBase(workspaceDir, bundlePath2) {
     }
   }
   return {
-    path: storablePath((0, import_node_path6.resolve)(workspaceDir), bundlePath2),
+    path: storablePath((0, import_node_path9.resolve)(workspaceDir), bundlePath2),
     removed: layers.length > 0,
     layers
   };
 }
 
 // src/commands/model.ts
-var import_zod5 = require("zod");
-var bundlePath = import_zod5.z.string().min(1).describe("Absolute path to the knowledge base directory.");
-var conceptId = import_zod5.z.string().min(1).describe("e.g. decision.cursor-v2");
-var REPO_ROOT = import_zod5.z.string().min(1).optional().describe(
+var import_zod6 = require("zod");
+var bundlePath = import_zod6.z.string().min(1).describe("Absolute path to the knowledge base directory.");
+var conceptId = import_zod6.z.string().min(1).describe("e.g. decision.cursor-v2");
+var REPO_ROOT = import_zod6.z.string().min(1).optional().describe(
   "Where the anchored source lives, for the drift check. Defaults to the working directory."
 );
 function define(command) {
@@ -1783,9 +2485,9 @@ function argvFlag(argv, name) {
     if (!value2) throw new KbMissingFlagValueError(name);
     return value2;
   }
-  const at = argv.indexOf(name);
-  if (at === -1) return void 0;
-  const value = argv[at + 1];
+  const at2 = argv.indexOf(name);
+  if (at2 === -1) return void 0;
+  const value = argv[at2 + 1];
   if (value === void 0 || value.startsWith("--")) {
     throw new KbMissingFlagValueError(name);
   }
@@ -1793,22 +2495,30 @@ function argvFlag(argv, name) {
 }
 
 // src/commands/anchor-resolve.ts
+function resolverSummary(results) {
+  const names = [
+    ...new Set(
+      results.flatMap((entry) => entry.resolver ? [entry.resolver] : [])
+    )
+  ].sort();
+  return names.length ? `${names.join(" + ")} resolver` : "whole-file";
+}
 var anchorResolveCommand = define({
   name: "anchor-resolve",
   tool: "kb_anchor_resolve",
   usage: "anchor-resolve <concept-id> [--repo-root <path>] [--offline] [--rebaseline] [--restamp]",
   description: "Resolve a record's anchors: stamp a hash onto anchors that lack one, report drift where the code moved. An anchor naming another repository is read from that remote through a bare cache; --offline uses the cache only. kb_verify's mechanical counterpart \u2014 reach for it when the question is whether the code still is what it was. Exits non-zero on drift.",
-  input: import_zod6.z.object({
+  input: import_zod7.z.object({
     bundlePath,
     conceptId,
-    repoRoot: import_zod6.z.string().min(1).optional(),
-    offline: import_zod6.z.boolean().optional().describe(
+    repoRoot: import_zod7.z.string().min(1).optional(),
+    offline: import_zod7.z.boolean().optional().describe(
       "Resolve foreign anchors from the local repo cache only, never fetching."
     ),
-    rebaseline: import_zod6.z.boolean().optional().describe(
+    rebaseline: import_zod7.z.boolean().optional().describe(
       "Accept the current code as the new baseline for anchors that drifted."
     ),
-    restamp: import_zod6.z.boolean().optional().describe(
+    restamp: import_zod7.z.boolean().optional().describe(
       "Refresh `resolved_at` on anchors that already match. Off by default, so a green run writes nothing."
     )
   }),
@@ -1837,6 +2547,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,
@@ -1853,27 +2568,39 @@ 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 currentHash = hashAnchorText(resolved.text);
+      const resolved = outcome.span;
+      const producedBy = outcome.resolver;
+      const { hash: currentHash, kind } = anchorHashOf(anchor, outcome);
       const currentLines = resolved.endLine - resolved.startLine + 1;
+      const stampedKind = outcome.normalized ? "ast" : "raw";
+      const stampedHash = outcome.normalized ? anchorHashOf({ ...anchor, hash: void 0 }, outcome).hash : currentHash;
       const stamped = {
         ...anchor,
-        hash: currentHash,
+        hash: stampedHash,
+        hash_kind: stampedKind,
         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: stampedHash,
+          hashKind: stampedKind,
+          ...producedBy ? { resolver: producedBy } : {}
+        });
         updated.push(stamped);
         dirty = true;
         continue;
@@ -1883,7 +2610,12 @@ var anchorResolveCommand = define({
           ...base2,
           state: "drifted",
           currentHash,
+          hashKind: kind,
           diffSize: lineDelta(anchor, currentLines),
+          ...producedBy ? { resolver: producedBy } : {},
+          // A regex-stamped anchor re-read by tree-sitter drifts because the
+          // resolver changed, not because the code did.
+          ...resolverChanged(source.source, anchor, producedBy) ? { reason: "resolver-changed" } : {},
           ...pinned ? { remoteState: "drifted-from-ref" } : {},
           ...rebaseline ? { rebaselined: true } : {}
         });
@@ -1891,7 +2623,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,
@@ -1907,6 +2639,8 @@ var anchorResolveCommand = define({
         ...base2,
         state: "match",
         currentHash,
+        hashKind: kind,
+        ...producedBy ? { resolver: producedBy } : {},
         ...pinned ? { remoteState: "matches-ref" } : {}
       });
       const refresh = restamp || anchor.resolved_at === void 0;
@@ -1924,19 +2658,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()
         );
@@ -1947,17 +2683,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:
@@ -1973,13 +2717,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) {
@@ -2029,13 +2773,13 @@ async function readSources(anchors, root, offline) {
 }
 
 // src/commands/answer.ts
-var import_zod7 = require("zod");
+var import_zod8 = require("zod");
 var answerCommand = define({
   name: "answer",
   tool: "kb_answer",
   usage: "answer <concept-id> <answer...>",
   description: "Resolve an open question: set status, stamp who and when, append an Answer section. If the answer overturns a decision or assumption, supersede that record explicitly.",
-  input: import_zod7.z.object({ bundlePath, conceptId, answer: import_zod7.z.string().min(1) }),
+  input: import_zod8.z.object({ bundlePath, conceptId, answer: import_zod8.z.string().min(1) }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
     conceptId: argv[1],
@@ -2049,19 +2793,19 @@ var answerCommand = define({
 });
 
 // src/commands/backlinks.ts
-var import_zod8 = require("zod");
+var import_zod9 = require("zod");
 var backlinksCommand = define({
   name: "backlinks",
   tool: "kb_backlinks",
   usage: "backlinks <concept-id>",
   description: "Who points at this record: every inbound typed causal link (`strauss_links`), one hop, every rel including `related_to`, each with its rel and the standing of the record that made it. Use it when you need the exact edges \u2014 reviewing or renaming a record.",
-  input: import_zod8.z.object({ bundlePath, conceptId }),
+  input: import_zod9.z.object({ bundlePath, conceptId }),
   fromArgv: (argv, path) => ({ bundlePath: path, conceptId: argv[1] }),
   run: async ({ store }, { bundlePath: path, conceptId: id }) => store.backlinks(path, id)
 });
 
 // src/commands/catalog.ts
-var import_zod9 = require("zod");
+var import_zod10 = require("zod");
 
 // src/adjudicate.ts
 var STANDING = {
@@ -2128,7 +2872,8 @@ function warningAnchor(entry) {
     diffSize,
     ...reason !== void 0 ? { reason } : {},
     ...repo !== void 0 ? { repo } : {},
-    ...remoteState !== void 0 ? { remoteState } : {}
+    ...remoteState !== void 0 ? { remoteState } : {},
+    ...entry.class !== void 0 ? { class: entry.class } : {}
   };
 }
 function resolveHeads(from, byId) {
@@ -2139,8 +2884,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)
@@ -2171,13 +2916,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
@@ -2232,9 +2977,9 @@ var catalogCommand = define({
   tool: "kb_catalog",
   usage: "catalog [type]",
   description: "Lists every record as one line \u2014 concept id, type, title, standing, and a stale flag \u2014 at roughly thirty tokens each. Pick this over kb_load once kb_load refuses: kb_catalog never refuses. Superseded records show only their replacement; fetch bodies with kb_load, kb_pack, kb_query, or kb_trace.",
-  input: import_zod9.z.object({
+  input: import_zod10.z.object({
     bundlePath,
-    type: import_zod9.z.enum(KB_RECORD_TYPES).optional()
+    type: import_zod10.z.enum(KB_RECORD_TYPES).optional()
   }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
@@ -2289,10 +3034,10 @@ function count(value, noun) {
 }
 
 // src/commands/context.ts
-var import_zod10 = require("zod");
+var import_zod11 = require("zod");
 
 // src/kb-context.ts
-var import_promises4 = require("fs/promises");
+var import_promises6 = require("fs/promises");
 
 // src/kb-index.ts
 var INDEX_FILE = "INDEX.md";
@@ -2519,13 +3264,13 @@ function toHookJson(block, event) {
 var CONTEXT_BEGIN = "<!-- strauss-kb:begin -->";
 var CONTEXT_END = "<!-- strauss-kb:end -->";
 async function syncInstructions(file, block) {
-  const existing = await (0, import_promises4.readFile)(file, "utf8").catch(() => null);
+  const existing = await (0, import_promises6.readFile)(file, "utf8").catch(() => null);
   const region = block ? `${CONTEXT_BEGIN}
 ${block.trim()}
 ${CONTEXT_END}` : null;
   if (existing === null) {
     if (!region) return { file, action: "unchanged" };
-    await (0, import_promises4.writeFile)(file, `${region}
+    await (0, import_promises6.writeFile)(file, `${region}
 `, "utf8");
     return { file, action: "created" };
   }
@@ -2536,11 +3281,11 @@ ${CONTEXT_END}` : null;
     const after = existing.slice(end + CONTEXT_END.length);
     const next = region ? `${before}${region}${after}` : `${before.replace(/\n+$/, "\n")}${after.replace(/^\n+/, "\n")}`;
     if (next === existing) return { file, action: "unchanged" };
-    await (0, import_promises4.writeFile)(file, next, "utf8");
+    await (0, import_promises6.writeFile)(file, next, "utf8");
     return { file, action: region ? "replaced" : "removed" };
   }
   if (!region) return { file, action: "unchanged" };
-  await (0, import_promises4.writeFile)(
+  await (0, import_promises6.writeFile)(
     file,
     `${existing.replace(/\n*$/, "\n\n")}${region}
 `,
@@ -2555,20 +3300,20 @@ var contextCommand = define({
   tool: "kb_context",
   usage: "context [--profile NAME] [--budget N] [--full-under N] [--format json] [--event NAME]",
   description: "Index block of pinned bases (ids, titles, standing) for injection at context birth. Takes no bundlePath \u2014 reads the workspace pin manifests. Empty when nothing is pinned; refuses over budget rather than truncating. Budget precedence: flags, then the manifest `context[profile]` over `context.default`, then the built-in profile, then package defaults.",
-  input: import_zod10.z.object({
-    budgetTokens: import_zod10.z.number().int().positive().optional().describe(
+  input: import_zod11.z.object({
+    budgetTokens: import_zod11.z.number().int().positive().optional().describe(
       "Ceiling on the whole emitted block; past it the command refuses with a list of bases rather than truncating. Defaults to 4000."
     ),
-    fullUnderTokens: import_zod10.z.number().int().positive().optional().describe(
+    fullUnderTokens: import_zod11.z.number().int().positive().optional().describe(
       "Per-base rendering threshold, applied before the budget: a base whose complete load fits under this arrives as full records instead of index lines, and the whole block still answers to budgetTokens. Off by default \u2014 index-only is the safe default at a context birth, because injected bodies outlive the qualifiers on them; the session-start profile opts tiny bases in at 1500."
     ),
-    profile: import_zod10.z.string().optional().describe(
+    profile: import_zod11.z.string().optional().describe(
       "Named budget set: built-ins are session-start (full-under 1500), compact and turn (budget 2500); the manifests' `context` tables override per repo. Unknown names fall through to defaults rather than failing."
     ),
-    format: import_zod10.z.enum(["markdown", "json"]).optional().describe(
+    format: import_zod11.z.enum(["markdown", "json"]).optional().describe(
       "CLI envelope for hook protocols that require strict JSON on stdout. MCP callers omit this \u2014 the block itself is identical."
     ),
-    event: import_zod10.z.string().optional().describe(
+    event: import_zod11.z.string().optional().describe(
       "hookEventName stamped into the JSON envelope. Only meaningful with format=json."
     )
   }),
@@ -2604,7 +3349,406 @@ var contextCommand = define({
 });
 
 // src/commands/doctor.ts
-var import_zod11 = require("zod");
+var import_zod13 = require("zod");
+
+// src/drift/git.ts
+var import_node_child_process3 = require("child_process");
+var import_node_util3 = require("util");
+var execFileAsync3 = (0, import_node_util3.promisify)(import_node_child_process3.execFile);
+var MAX_GIT_OUTPUT_BYTES = 1048576;
+var GIT_TIMEOUT_MS = 5e3;
+async function git2(cwd, args) {
+  const env = { ...process.env };
+  delete env["GIT_DIR"];
+  delete env["GIT_WORK_TREE"];
+  delete env["GIT_INDEX_FILE"];
+  try {
+    const { stdout } = await execFileAsync3("git", ["-C", cwd, ...args], {
+      timeout: GIT_TIMEOUT_MS,
+      maxBuffer: MAX_GIT_OUTPUT_BYTES,
+      env
+    });
+    return { ok: true, stdout };
+  } catch {
+    return { ok: false };
+  }
+}
+async function listRepoFiles(repoRoot) {
+  const result = await git2(repoRoot, ["ls-files", "-z", "--cached"]);
+  if (!result.ok) return [];
+  return result.stdout.split("\0").filter(Boolean);
+}
+async function readOldSource(repoRoot, anchor) {
+  if (!filePathIsSafe(anchor.file))
+    return { ok: false, reason: "unrecoverable" };
+  if (anchor.ref && refShapeIsSafe(anchor.ref)) {
+    const shown2 = await showFile(repoRoot, anchor.ref, anchor.file);
+    if (shown2 !== null) {
+      return {
+        ok: true,
+        source: shown2,
+        origin: { kind: "ref", ref: anchor.ref }
+      };
+    }
+  }
+  const at2 = anchor.resolved_at;
+  if (!at2 || Number.isNaN(Date.parse(at2))) {
+    return { ok: false, reason: "unrecoverable" };
+  }
+  const found = await git2(repoRoot, [
+    "log",
+    "-1",
+    "--format=%H",
+    `--before=${at2}`,
+    "--end-of-options",
+    "HEAD",
+    "--",
+    anchor.file
+  ]);
+  const sha = found.ok ? found.stdout.trim() : "";
+  if (!sha || !refShapeIsSafe(sha))
+    return { ok: false, reason: "unrecoverable" };
+  const shown = await showFile(repoRoot, sha, anchor.file);
+  if (shown === null) return { ok: false, reason: "unrecoverable" };
+  return { ok: true, source: shown, origin: { kind: "history", ref: sha } };
+}
+async function showFile(repoRoot, ref, file) {
+  const path = file.replace(/^\.\//, "");
+  const result = await git2(repoRoot, [
+    "show",
+    "--end-of-options",
+    `${ref}:${path}`
+  ]);
+  return result.ok ? result.stdout : null;
+}
+
+// src/drift/moved.ts
+var import_promises7 = require("fs/promises");
+var MAX_MOVED_SEARCH_FILES = 2e3;
+var SEARCH_BATCH = 64;
+function movedSearch(repoRoot, options = {}) {
+  const read = options.reader ?? anchorFileReader(repoRoot);
+  const sizeOf = options.sizeOf ?? diskSize(repoRoot);
+  const resolver = new TreeSitterResolver();
+  let repoFiles;
+  const prepared = /* @__PURE__ */ new Set();
+  const filesForLanguage = async (language) => {
+    repoFiles ??= listRepoFiles(repoRoot);
+    return (await repoFiles).filter((file) => languageForFile(file) === language).slice(0, MAX_MOVED_SEARCH_FILES);
+  };
+  return {
+    async find(anchor) {
+      const stored = anchor.hash;
+      if (!stored) return void 0;
+      const language = languageForFile(anchor.file);
+      if (!language) return sameFileWindow(anchor, read, stored);
+      const candidates = await filesForLanguage(language);
+      if (!prepared.has(language)) {
+        await resolver.prepare(candidates.length ? candidates : [anchor.file]);
+        prepared.add(language);
+      }
+      const floor = anchor.lines ?? 0;
+      for (let at2 = 0; at2 < candidates.length; at2 += SEARCH_BATCH) {
+        const batch = candidates.slice(at2, at2 + SEARCH_BATCH);
+        const hits = await mapLimit(
+          batch,
+          DEFAULT_IO_CONCURRENCY,
+          async (file) => {
+            const size2 = await sizeOf(file);
+            if (size2 !== null && size2 < floor) return void 0;
+            return matchIn(resolver, read, anchor, stored, file);
+          }
+        );
+        const found = hits.find((hit) => hit !== void 0);
+        if (found) return found;
+      }
+      return void 0;
+    }
+  };
+}
+async function matchIn(resolver, read, anchor, stored, file) {
+  const source = await read(file);
+  if (!source.ok) return void 0;
+  const normalized = source.source.replace(/\r\n/g, "\n");
+  for (const found of resolver.spans(normalized, file)) {
+    const text = anchor.hash_kind === "ast" ? resolver.normalize(found.span.text, file) : found.span.text;
+    if (text === null || hashAnchorText(text) !== stored) continue;
+    if (file === anchor.file && found.symbol === anchor.symbol) continue;
+    return {
+      file,
+      symbol: found.symbol,
+      startLine: found.span.startLine,
+      endLine: found.span.endLine
+    };
+  }
+  return void 0;
+}
+function diskSize(repoRoot) {
+  return async (file) => {
+    const path = anchorFilePath(repoRoot, file);
+    if (path === null) return null;
+    try {
+      return (await (0, import_promises7.stat)(path)).size;
+    } catch {
+      return null;
+    }
+  };
+}
+async function sameFileWindow(anchor, read, stored) {
+  const height = anchor.lines;
+  if (!height || anchor.hash_kind === "ast") return void 0;
+  const source = await read(anchor.file);
+  if (!source.ok) return void 0;
+  const lines = source.source.replace(/\r\n/g, "\n").split("\n");
+  for (let at2 = 0; at2 + height <= lines.length; at2++) {
+    if (hashAnchorText(lines.slice(at2, at2 + height).join("\n")) !== stored) {
+      continue;
+    }
+    return {
+      file: anchor.file,
+      ...anchor.symbol ? { symbol: anchor.symbol } : {},
+      startLine: at2 + 1,
+      endLine: at2 + height
+    };
+  }
+  return void 0;
+}
+
+// src/drift/classify.ts
+async function classifyDrift(repoRoot, record, entries, options = {}) {
+  const anchors = (record.frontmatter.strauss_anchors ?? []).filter(
+    (anchor) => anchor.hash
+  );
+  const reader = options.reader ?? anchorFileReader(repoRoot);
+  const treeSitter = new TreeSitterResolver();
+  const resolvers = [treeSitter, regexResolver];
+  const search = options.search ?? movedSearch(repoRoot, { ...options.reader ? { reader } : {} });
+  const wanted = [];
+  entries.forEach((entry, at2) => {
+    const anchor = anchors[at2];
+    if (!anchor) return;
+    if (entry.state === "match" || isUncheckedReason(entry.reason)) return;
+    wanted.push({ anchor, entry });
+  });
+  if (!wanted.length) return [];
+  await prepareResolvers(
+    resolvers,
+    wanted.map(({ anchor }) => anchor.file)
+  );
+  const out = [];
+  for (const { anchor, entry } of wanted) {
+    const movedTo = await search.find(anchor);
+    if (movedTo) {
+      out.push({
+        anchor,
+        entry: { ...entry, class: "moved", movedTo },
+        class: "moved"
+      });
+      continue;
+    }
+    const newText = await currentText(reader, anchor, resolvers);
+    const old = options.withHistory === false ? { ok: false, reason: "unrecoverable" } : await readOldSource(repoRoot, anchor);
+    const oldText = old.ok ? spanIn(old.source, anchor, resolvers) : void 0;
+    const settled = newText !== void 0 && oldText !== void 0 && sameTokens(treeSitter, anchor.file, oldText, newText) ? "cosmetic" : entry.class ?? "changed";
+    out.push({
+      anchor,
+      entry: { ...entry, class: settled },
+      class: settled,
+      ...newText !== void 0 ? { newText } : {},
+      ...oldText !== void 0 ? { oldText } : {},
+      ...old.ok ? { oldOrigin: old.origin } : {}
+    });
+  }
+  return out;
+}
+function sameTokens(resolver, file, before, after) {
+  if (before === after) return false;
+  const left = resolver.normalize(before, file);
+  const right = resolver.normalize(after, file);
+  return left !== null && left === right;
+}
+async function currentText(reader, anchor, resolvers) {
+  const read = await reader(anchor.file);
+  if (!read.ok) return void 0;
+  return spanIn(read.source, anchor, resolvers);
+}
+function spanIn(source, anchor, resolvers) {
+  const outcome = resolveAnchorSpan(source, anchor, resolvers);
+  return outcome.ok ? outcome.span.text : void 0;
+}
+
+// src/drift/diff.ts
+var MAX_ANCHOR_DIFF_LINES = 200;
+var PACKET_DIFF_LINE_BUDGET = 200;
+var MIN_ANCHOR_DIFF_LINES = 12;
+function diffBudget(anchors) {
+  if (anchors <= 0) return MAX_ANCHOR_DIFF_LINES;
+  return Math.min(
+    MAX_ANCHOR_DIFF_LINES,
+    Math.max(
+      MIN_ANCHOR_DIFF_LINES,
+      Math.floor(PACKET_DIFF_LINE_BUDGET / anchors)
+    )
+  );
+}
+function unifiedDiff(before, after, options = {}) {
+  const max = options.maxLines ?? MAX_ANCHOR_DIFF_LINES;
+  const left = before.replace(/\r\n/g, "\n").split("\n");
+  const right = after.replace(/\r\n/g, "\n").split("\n");
+  const body = [];
+  let added = 0;
+  let removed = 0;
+  for (const edit of edits(left, right)) {
+    if (edit.kind === "same") body.push(` ${edit.line}`);
+    else if (edit.kind === "remove") {
+      body.push(`-${edit.line}`);
+      removed += 1;
+    } else {
+      body.push(`+${edit.line}`);
+      added += 1;
+    }
+  }
+  const truncated = body.length > max;
+  const shown = truncated ? body.slice(0, max) : body;
+  const header = `@@ -1,${left.length} +1,${right.length} @@${options.oldLabel ? ` ${options.oldLabel} \u2192 ${options.newLabel ?? ""}`.trimEnd() : ""}`;
+  const lines = [header, ...shown];
+  if (truncated) lines.push(`\u2026 ${body.length - max} more diff lines`);
+  return { text: lines.join("\n"), added, removed, truncated };
+}
+function edits(left, right) {
+  const rows = left.length;
+  const cols = right.length;
+  const table2 = Array.from(
+    { length: rows + 1 },
+    () => new Array(cols + 1).fill(0)
+  );
+  for (let row2 = rows - 1; row2 >= 0; row2--) {
+    for (let col2 = cols - 1; col2 >= 0; col2--) {
+      table2[row2][col2] = left[row2] === right[col2] ? table2[row2 + 1][col2 + 1] + 1 : Math.max(
+        table2[row2 + 1][col2],
+        table2[row2][col2 + 1]
+      );
+    }
+  }
+  const out = [];
+  let row = 0;
+  let col = 0;
+  while (row < rows && col < cols) {
+    if (left[row] === right[col]) {
+      out.push({ kind: "same", line: left[row] });
+      row += 1;
+      col += 1;
+    } else if (table2[row + 1][col] >= table2[row][col + 1]) {
+      out.push({ kind: "remove", line: left[row] });
+      row += 1;
+    } else {
+      out.push({ kind: "add", line: right[col] });
+      col += 1;
+    }
+  }
+  for (; row < rows; row++)
+    out.push({ kind: "remove", line: left[row] });
+  for (; col < cols; col++)
+    out.push({ kind: "add", line: right[col] });
+  return out;
+}
+
+// src/drift/packet.ts
+var PRESUMED_INVALID = [
+  "fact",
+  "constraint",
+  "contract"
+];
+var RATIONALE_SURVIVES = ["decision", "risk"];
+var DEFAULT_NOTES = {
+  "presumed-invalidated": "the code this claim was taken from changed; presume it no longer holds until re-read",
+  "rationale-may-survive": "the reasoning may outlive the code that implemented it; check whether it does",
+  review: "re-read the record against the new code"
+};
+async function reassessPacket(repoRoot, record, entries, options = {}) {
+  const classified = await classifyDrift(repoRoot, record, entries, {
+    ...options.reader ? { reader: options.reader } : {},
+    ...options.search ? { search: options.search } : {},
+    withHistory: options.withDiff !== false
+  });
+  const open = classified.filter(
+    (found) => found.class === "changed" || found.class === "gone"
+  );
+  if (!open.length) return { packet: null, classified };
+  const budget = diffBudget(open.length);
+  const anchors = open.map(
+    (found) => anchorPacket(found, options.withDiff === true, budget)
+  );
+  const type = record.frontmatter.type;
+  const fallback = isKbRecordType(type) ? PRESUMED_INVALID.includes(type) ? "presumed-invalidated" : RATIONALE_SURVIVES.includes(type) ? "rationale-may-survive" : "review" : "review";
+  return {
+    classified,
+    packet: {
+      conceptId: record.conceptId,
+      title: record.frontmatter.title ?? null,
+      type,
+      standing: options.standing ?? "unsettled",
+      why: record.frontmatter.description ?? null,
+      claim: claimOf(record),
+      anchors,
+      impact: (options.impact?.impacted ?? []).map((entry) => ({
+        conceptId: entry.conceptId,
+        title: entry.title,
+        standing: entry.standing,
+        depth: entry.depth
+      })),
+      impactTruncated: options.impact?.truncated ?? false,
+      default: fallback,
+      defaultNote: DEFAULT_NOTES[fallback]
+    }
+  };
+}
+function anchorPacket(found, withDiff, maxLines) {
+  const { entry } = found;
+  const base2 = {
+    file: entry.file,
+    ...entry.symbol ? { symbol: entry.symbol } : {},
+    class: found.class,
+    ...entry.reason ? { reason: entry.reason } : {},
+    storedHash: entry.storedHash,
+    ...entry.currentHash ? { currentHash: entry.currentHash } : {},
+    diffSize: entry.diffSize,
+    ...entry.movedTo ? { movedTo: entry.movedTo } : {}
+  };
+  if (!withDiff) return base2;
+  if (found.oldText === void 0 || !found.oldOrigin) {
+    return { ...base2, diff: { status: "unrecoverable" } };
+  }
+  const rendered = unifiedDiff(found.oldText, found.newText ?? "", {
+    maxLines
+  });
+  return {
+    ...base2,
+    diff: {
+      status: "ok",
+      source: found.oldOrigin.kind,
+      ref: found.oldOrigin.ref,
+      unified: rendered.text,
+      added: rendered.added,
+      removed: rendered.removed,
+      truncated: rendered.truncated
+    }
+  };
+}
+function claimOf(record) {
+  const type = record.frontmatter.type;
+  const section = isKbRecordType(type) ? RECORD_TYPES[type].sections[0] : void 0;
+  if (!section) return null;
+  const lines = record.body.replace(/\r\n/g, "\n").split("\n");
+  const start = lines.findIndex(
+    (line) => line.trim().toLowerCase() === `## ${section}`.toLowerCase()
+  );
+  if (start < 0) return null;
+  const rest = lines.slice(start + 1);
+  const end = rest.findIndex((line) => line.startsWith("## "));
+  const text = (end < 0 ? rest : rest.slice(0, end)).join("\n").trim();
+  return text ? { section, text } : null;
+}
 
 // src/kb-edges.ts
 var KB_EDGE_KINDS = [
@@ -2790,6 +3934,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,
@@ -2825,6 +3981,7 @@ function doctor(bundle, options = {}) {
     counts,
     groups,
     findingCount,
+    anchorResolvers: anchorResolverCounts(bundle),
     healthy: findingCount === 0
   };
 }
@@ -2841,18 +3998,18 @@ function expired(hits, now) {
   for (const hit of hits) {
     const raw = hit.record.frontmatter.stale_after;
     if (!raw) continue;
-    const at = Date.parse(raw);
-    if (Number.isNaN(at)) {
+    const at2 = Date.parse(raw);
+    if (Number.isNaN(at2)) {
       findings.push(
         finding(hit.record, `stale_after "${raw}" is not a readable date`)
       );
       continue;
     }
-    if (at < now.getTime()) {
+    if (at2 < now.getTime()) {
       findings.push(
         finding(
           hit.record,
-          `stale since ${raw} (${daysBetween(at, now.getTime())} days ago)`
+          `stale since ${raw} (${daysBetween(at2, now.getTime())} days ago)`
         )
       );
     }
@@ -2865,12 +4022,12 @@ function expiring(hits, now, withinDays) {
   for (const hit of hits) {
     const raw = hit.record.frontmatter.stale_after;
     if (!raw) continue;
-    const at = Date.parse(raw);
-    if (Number.isNaN(at) || at < now.getTime() || at > horizon) continue;
+    const at2 = Date.parse(raw);
+    if (Number.isNaN(at2) || at2 < now.getTime() || at2 > horizon) continue;
     findings.push(
       finding(
         hit.record,
-        `goes stale ${raw} (in ${daysBetween(now.getTime(), at)} days)`
+        `goes stale ${raw} (in ${daysBetween(now.getTime(), at2)} days)`
       )
     );
   }
@@ -3040,13 +4197,16 @@ function anchorFindings(hits, kind, headline) {
   );
 }
 function describeAnchor(anchor) {
-  const at = anchor.symbol ? `${anchor.file}:${anchor.symbol}` : anchor.file;
-  if (anchor.reason) return `${at} (${anchor.reason})`;
+  const at2 = anchor.symbol ? `${anchor.file}:${anchor.symbol}` : anchor.file;
+  if (anchor.class === "gone") {
+    return `${at2} gone${anchor.reason ? ` (${anchor.reason})` : ""}`;
+  }
+  if (anchor.reason) return `${at2} (${anchor.reason})`;
   if (anchor.remoteState === "drifted-on-default") {
-    return `${at} (matches ref, moved on the default branch)`;
+    return `${at2} (matches ref, moved on the default branch)`;
   }
-  if (anchor.diffSize === null) return `${at} (changed, size unrecorded)`;
-  return anchor.diffSize === 0 ? `${at} (content changed, same line count)` : `${at} (${anchor.diffSize} line${anchor.diffSize === 1 ? "" : "s"} apart)`;
+  if (anchor.diffSize === null) return `${at2} (changed, size unrecorded)`;
+  return anchor.diffSize === 0 ? `${at2} (content changed, same line count)` : `${at2} (${anchor.diffSize} line${anchor.diffSize === 1 ? "" : "s"} apart)`;
 }
 function replaces(later, earlier) {
   return (later.frontmatter.strauss_supersedes ?? []).includes(earlier.conceptId) || earlier.frontmatter.strauss_superseded_by === later.conceptId;
@@ -3063,21 +4223,173 @@ function daysBetween(from, to) {
   return Math.max(0, Math.floor((to - from) / DAY_MS));
 }
 function ageInDays(record, now) {
-  const at = record.frontmatter.generated?.at;
-  if (!at) return null;
-  const written = Date.parse(at);
+  const at2 = record.frontmatter.generated?.at;
+  if (!at2) return null;
+  const written = Date.parse(at2);
   if (Number.isNaN(written)) return null;
   return daysBetween(written, now.getTime());
 }
 
+// src/commands/reassess.ts
+var import_zod12 = require("zod");
+var reassessCommand = define({
+  name: "reassess",
+  tool: "kb_reassess",
+  usage: "reassess <concept-id> [--repo-root <path>] [--with-diff]",
+  description: "One drifted record, as something to judge: its claim, each anchor's drift class, the old-vs-new span diff, and the records that depend on it. Formatting-only drift is dropped. Empty when there is nothing to reassess. Writes: relocates moved anchors, keeping their hash; never verifies, supersedes, or changes standing.",
+  input: import_zod12.z.object({
+    bundlePath,
+    conceptId,
+    repoRoot: REPO_ROOT,
+    withDiff: import_zod12.z.boolean().optional().describe(
+      "Recover each anchor's committed span and render the diff. Reads git history."
+    )
+  }),
+  fromArgv: (argv, path) => {
+    const repoRoot = argvFlag(argv, "--repo-root");
+    return {
+      bundlePath: path,
+      conceptId: argv[1],
+      ...repoRoot !== void 0 ? { repoRoot } : {},
+      ...argv.includes("--with-diff") ? { withDiff: true } : {}
+    };
+  },
+  run: async ({ store, actor }, { bundlePath: path, conceptId: id, repoRoot, withDiff }) => {
+    const root = repoRoot ?? process.cwd();
+    const bundle = await store.list(path);
+    const record = bundle.find((entry) => entry.conceptId === id);
+    if (!record) throw new KbRecordNotFoundError(id);
+    const drift = await store.detectDrift([record], repoRoot);
+    const entries = drift?.get(id) ?? [];
+    if (!entries.some((entry) => entry.state !== "match")) {
+      return { conceptId: id, packet: null, rebaselined: [], cosmetic: 0 };
+    }
+    const standing = adjudicate(bundle, bundle).find(
+      (hit) => hit.record.conceptId === id
+    )?.standing;
+    const impact2 = await store.impact(path, id);
+    const { packet, classified } = await reassessPacket(root, record, entries, {
+      ...withDiff ? { withDiff: true } : {},
+      impact: impact2,
+      ...standing ? { standing } : {}
+    });
+    const moves = classified.filter((found) => found.class === "moved");
+    let frozen = false;
+    const rebaselined = [];
+    if (moves.length) {
+      const relocated = /* @__PURE__ */ new Map();
+      for (const found of moves) {
+        const to = found.entry.movedTo;
+        if (!to) continue;
+        relocated.set(found.anchor, {
+          ...found.anchor,
+          file: to.file,
+          ...to.symbol ? { symbol: to.symbol } : {}
+        });
+        rebaselined.push({
+          file: found.anchor.file,
+          ...found.anchor.symbol ? { symbol: found.anchor.symbol } : {},
+          toFile: to.file,
+          ...to.symbol ? { toSymbol: to.symbol } : {}
+        });
+      }
+      try {
+        await assertBaseNotFrozen(process.cwd(), path);
+      } catch (error) {
+        if (!(error instanceof KbBaseFrozenError)) throw error;
+        frozen = true;
+      }
+      if (!frozen) {
+        await store.updateAnchors(
+          path,
+          id,
+          (record.frontmatter.strauss_anchors ?? []).map(
+            (anchor) => relocated.get(anchor) ?? anchor
+          ),
+          actor
+        );
+      }
+    }
+    return {
+      conceptId: id,
+      packet,
+      rebaselined: frozen ? [] : rebaselined,
+      cosmetic: classified.filter((found) => found.class === "cosmetic").length,
+      ...frozen ? {
+        frozen: true,
+        note: "base is frozen: nothing was rebaselined"
+      } : {}
+    };
+  },
+  render: (result) => renderReassess(result)
+});
+function renderReassess(result) {
+  const lines = [];
+  for (const move of result.rebaselined) {
+    lines.push(
+      `rebaselined: ${at(move.file, move.symbol)} \u2192 ${at(move.toFile, move.toSymbol)} (same code, new address)`
+    );
+  }
+  if (result.cosmetic) {
+    lines.push(
+      `${result.cosmetic} anchor${result.cosmetic === 1 ? "" : "s"} changed formatting only.`
+    );
+  }
+  if (result.note) lines.push(result.note);
+  const packet = result.packet;
+  if (!packet) {
+    lines.push(`${result.conceptId}: nothing to reassess.`);
+    return lines.join("\n");
+  }
+  lines.push(
+    "",
+    `# ${packet.conceptId}${packet.title ? ` \u2014 ${packet.title}` : ""}`,
+    `type: ${packet.type}   standing: ${packet.standing}`,
+    ...packet.why ? [`why: ${packet.why}`] : [],
+    ...packet.claim ? ["", `## ${packet.claim.section}`, packet.claim.text] : [],
+    "",
+    `## Anchors (${packet.anchors.length})`
+  );
+  for (const anchor of packet.anchors) {
+    lines.push(
+      `- ${at(anchor.file, anchor.symbol)} \u2014 ${anchor.class}${anchor.reason ? ` (${anchor.reason})` : ""}`
+    );
+    if (!anchor.diff) continue;
+    if (anchor.diff.status === "unrecoverable") {
+      lines.push(
+        "  diff: unrecoverable \u2014 no committed span to compare against"
+      );
+      continue;
+    }
+    lines.push(
+      `  diff vs ${anchor.diff.ref} (${anchor.diff.source}): +${anchor.diff.added} \u2212${anchor.diff.removed}`,
+      ...anchor.diff.unified.split("\n").map((line) => `  ${line}`)
+    );
+  }
+  if (packet.impact.length) {
+    lines.push("", `## Impact (${packet.impact.length})`);
+    for (const entry of packet.impact) {
+      lines.push(
+        `- ${entry.conceptId} [${entry.standing}]${entry.title ? ` \u2014 ${entry.title}` : ""}`
+      );
+    }
+    if (packet.impactTruncated) lines.push("- \u2026 walk truncated");
+  }
+  lines.push("", `Default: ${packet.default} \u2014 ${packet.defaultNote}.`);
+  return lines.join("\n");
+}
+function at(file, symbol) {
+  return symbol ? `${file}:${symbol}` : file;
+}
+
 // src/commands/doctor.ts
-var days = (what, fallback) => import_zod11.z.number().int().positive().optional().describe(`${what} Defaults to ${fallback}.`);
+var days = (what, fallback) => import_zod13.z.number().int().positive().optional().describe(`${what} Defaults to ${fallback}.`);
 var doctorCommand = define({
   name: "doctor",
   tool: "kb_doctor",
-  usage: "doctor [--expiring-days N] [--unverified-days N] [--aging-days N] [--repo-root PATH] [--offline] [--strict]",
-  description: "Read-only health sweep: expired, expiring, unverified, aging, orphaned, broken-supersession, superseded-but-cited, drifted and unchecked anchors. Every group is reported even when empty; nothing is written or re-stamped. Use it when picking up a base you have not touched in a while; kb_validate only checks that pointers between records agree.",
-  input: import_zod11.z.object({
+  usage: "doctor [--expiring-days N] [--unverified-days N] [--aging-days N] [--repo-root PATH] [--offline] [--strict] [--drifted [--with-diff]]",
+  description: "Read-only health sweep: expired, expiring, unverified, aging, orphaned, broken-supersession, superseded-but-cited, drifted and unchecked anchors. Every group is reported even when empty; nothing is written or re-stamped. `drifted` narrows it to a reassessment packet per drifted record, `with_diff` adding each anchor's old-vs-new span.",
+  input: import_zod13.z.object({
     bundlePath,
     repoRoot: REPO_ROOT,
     expiringDays: days(
@@ -3092,11 +4404,17 @@ var doctorCommand = define({
       "How long a record may stay `open` or `proposed` before `aging` reports it, in days.",
       DEFAULT_AGING_DAYS
     ),
-    offline: import_zod11.z.boolean().optional().describe(
+    offline: import_zod13.z.boolean().optional().describe(
       "Read foreign anchors from the local repo cache only, never fetching."
     ),
-    strict: import_zod11.z.boolean().optional().describe(
+    strict: import_zod13.z.boolean().optional().describe(
       "Turn an expired record into a non-zero exit for the CLI. No effect on the report itself."
+    ),
+    drifted: import_zod13.z.boolean().optional().describe(
+      "Report only drift, as a reassessment packet per record: claim, per-anchor class, and what depends on it."
+    ),
+    withDiff: import_zod13.z.boolean().optional().describe(
+      "With `drifted`: recover each anchor's committed span and render the old-vs-new diff. Reads git history."
     )
   }),
   // Presence, not truthiness: `--expiring-days ""` is a caller who meant
@@ -3115,7 +4433,9 @@ var doctorCommand = define({
       ...unverified2 !== void 0 ? { unverifiedDays: Number(unverified2) } : {},
       ...agingDays !== void 0 ? { agingDays: Number(agingDays) } : {},
       ...argv.includes("--offline") ? { offline: true } : {},
-      ...argv.includes("--strict") ? { strict: true } : {}
+      ...argv.includes("--strict") ? { strict: true } : {},
+      ...argv.includes("--drifted") ? { drifted: true } : {},
+      ...argv.includes("--with-diff") ? { withDiff: true } : {}
     };
   },
   run: async ({ store, now }, {
@@ -3124,7 +4444,9 @@ var doctorCommand = define({
     unverifiedDays,
     agingDays,
     repoRoot,
-    offline
+    offline,
+    drifted: drifted2,
+    withDiff
   }) => {
     const checkedAt = now();
     const records = await store.list(path);
@@ -3138,7 +4460,54 @@ var doctorCommand = define({
       ...anchorDrift !== void 0 ? { anchorDrift } : {},
       now: new Date(checkedAt)
     });
-    return { bundlePath: path, checkedAt, ...report };
+    const hints = grammarHints();
+    if (!drifted2) {
+      return {
+        bundlePath: path,
+        checkedAt,
+        ...report,
+        ...hints.length ? { hints } : {}
+      };
+    }
+    const standings = new Map(
+      adjudicate(records, records, new Date(checkedAt)).map((hit) => [
+        hit.record.conceptId,
+        hit.standing
+      ])
+    );
+    const packets = [];
+    const rebaselinable = [];
+    const search = movedSearch(repoRoot ?? process.cwd());
+    for (const found of report.groups.find((g) => g.check === "drifted")?.findings ?? []) {
+      const record = records.find(
+        (entry) => entry.conceptId === found.conceptId
+      );
+      if (!record) continue;
+      const standing = standings.get(record.conceptId);
+      const built = await reassessPacket(
+        repoRoot ?? process.cwd(),
+        record,
+        anchorDrift?.get(record.conceptId) ?? [],
+        {
+          ...withDiff ? { withDiff: true } : {},
+          impact: await store.impact(path, record.conceptId),
+          ...standing ? { standing } : {},
+          search
+        }
+      );
+      if (built.packet) packets.push(built.packet);
+      if (built.classified.some((entry) => entry.class === "moved")) {
+        rebaselinable.push(record.conceptId);
+      }
+    }
+    return {
+      bundlePath: path,
+      checkedAt,
+      ...report,
+      packets,
+      rebaselinable,
+      ...hints.length ? { hints } : {}
+    };
   },
   render: (result) => render2(result),
   // Only expiry, and only under --strict. The other seven checks report debt a
@@ -3150,18 +4519,22 @@ var doctorCommand = define({
   failsWhen: (result, input) => input.strict === true && result.counts.expired > 0
 });
 function render2(result) {
+  if (result.packets) return renderPackets(result);
   const { thresholds } = result;
   const lines = [
     `# KB Doctor \u2014 ${result.bundlePath}`,
     `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) {
@@ -3173,27 +4546,52 @@ 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.`
   );
   return lines.join("\n");
 }
+function renderPackets(result) {
+  const packets = result.packets ?? [];
+  const lines = [
+    `# KB Drift \u2014 ${result.bundlePath}`,
+    `checked: ${result.checkedAt}`,
+    `${packets.length} record${packets.length === 1 ? "" : "s"} need a reading; ${result.counts.drifted} drifted in all.`
+  ];
+  if (result.rebaselinable?.length) {
+    lines.push(
+      `moved, rebaseline with \`kb_reassess\`: ${result.rebaselinable.join(", ")}`
+    );
+  }
+  for (const packet of packets) {
+    lines.push(
+      renderReassess({
+        conceptId: packet.conceptId,
+        packet,
+        rebaselined: [],
+        cosmetic: 0
+      })
+    );
+  }
+  return lines.join("\n");
+}
 
 // src/commands/impact.ts
-var import_zod12 = require("zod");
+var import_zod14 = require("zod");
 var impactCommand = define({
   name: "impact",
   tool: "kb_impact",
   usage: "impact <concept-id> [--depth N] [--rels a,b]",
   description: "What breaks if this record changes: its transitive set of dependants, each with its standing. Each rel declares which of its ends depends on the other, and the walk follows each rel in its own direction. Naming `related_to` or an unknown rel in `rels` is an error. kb_backlinks gives one flat hop.",
-  input: import_zod12.z.object({
+  input: import_zod14.z.object({
     bundlePath,
     conceptId,
-    depth: import_zod12.z.number().int().positive().optional().describe(
+    depth: import_zod14.z.number().int().positive().optional().describe(
       "Hops out from the record. Unbounded when omitted; a walk this cuts reports truncated: true."
     ),
-    rels: import_zod12.z.array(import_zod12.z.enum(KB_CAUSAL_LINK_RELS)).optional().describe(
+    rels: import_zod14.z.array(import_zod14.z.enum(KB_CAUSAL_LINK_RELS)).optional().describe(
       "Narrow which rels the walk follows. Defaults to every rel that carries a dependence \u2014 all but related_to."
     )
   }),
@@ -3214,13 +4612,13 @@ var impactCommand = define({
 });
 
 // src/commands/list.ts
-var import_zod13 = require("zod");
+var import_zod15 = require("zod");
 var listCommand = define({
   name: "list",
   tool: "kb_list",
   usage: "list [type]",
   description: "Every record, optionally one type. For enumerating; use kb_query for a question.",
-  input: import_zod13.z.object({ bundlePath, type: import_zod13.z.enum(KB_RECORD_TYPES).optional() }),
+  input: import_zod15.z.object({ bundlePath, type: import_zod15.z.enum(KB_RECORD_TYPES).optional() }),
   fromArgv: (argv, path) => ({ bundlePath: path, type: argv[1] }),
   run: async ({ store }, { bundlePath: path, type }) => (await store.list(path, type)).map((record) => ({
     conceptId: record.conceptId,
@@ -3232,17 +4630,17 @@ var listCommand = define({
 });
 
 // src/commands/load.ts
-var import_zod14 = require("zod");
+var import_zod16 = require("zod");
 var loadCommand = define({
   name: "load",
   tool: "kb_load",
   usage: "load [type] [--budget N | --all] [--repo-root PATH]",
   description: "Load the whole base, each record with its standing \u2014 call it first, at the point of use, since compaction drops it. Superseded records arrive as stubs; kb_trace has the history. Over budget it refuses: kb_catalog, then kb_pack, or narrow with `type`; `all` bypasses. Never read record files directly \u2014 only kb_* tools resolve supersession. `digest` stamps the base's content, so hooks know when to reload.",
-  input: import_zod14.z.object({
+  input: import_zod16.z.object({
     bundlePath,
-    type: import_zod14.z.enum(KB_RECORD_TYPES).optional(),
-    budgetTokens: import_zod14.z.number().int().positive().optional().describe("Approximate token ceiling. Defaults to 25000."),
-    all: import_zod14.z.boolean().optional().describe(
+    type: import_zod16.z.enum(KB_RECORD_TYPES).optional(),
+    budgetTokens: import_zod16.z.number().int().positive().optional().describe("Approximate token ceiling. Defaults to 25000."),
+    all: import_zod16.z.boolean().optional().describe(
       "Loads the entire base regardless of size, bypassing the token budget; mutually exclusive with budgetTokens."
     ),
     repoRoot: REPO_ROOT
@@ -3284,25 +4682,25 @@ var loadCommand = define({
 });
 
 // src/commands/log.ts
-var import_zod15 = require("zod");
+var import_zod17 = require("zod");
 var logCommand = define({
   name: "log",
   tool: "kb_log",
   usage: "log",
   description: "Who touched what, and when. Append-only; malformed lines are reported, never repaired.",
-  input: import_zod15.z.object({ bundlePath }),
+  input: import_zod17.z.object({ bundlePath }),
   fromArgv: (_argv, path) => ({ bundlePath: path }),
   run: ({ store }, { bundlePath: path }) => store.readLog(path)
 });
 
 // src/commands/no-decision.ts
-var import_zod16 = require("zod");
+var import_zod18 = require("zod");
 var noDecisionCommand = define({
   name: "no-decision",
   tool: "kb_no_decision",
   usage: "no-decision <reason...>",
   description: "Record in one sentence that a piece of work had nothing to decide. Idempotent.",
-  input: import_zod16.z.object({ bundlePath, reason: import_zod16.z.string().min(1) }),
+  input: import_zod18.z.object({ bundlePath, reason: import_zod18.z.string().min(1) }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
     reason: argv.slice(1).join(" ").trim()
@@ -3319,20 +4717,20 @@ var noDecisionCommand = define({
 });
 
 // src/commands/pack.ts
-var import_zod17 = require("zod");
+var import_zod19 = require("zod");
 var packCommand = define({
   name: "pack",
   tool: "kb_pack",
   usage: "pack <conceptId> [--hops N] [--max-nodes N] [--budget N]",
   description: "Bounded neighbourhood around one record: within `hops`, ranked, cut to `maxNodes`, with every cut record named under Excluded. Use when the base is over kb_load's budget and the work centres on a record you can name. Refuses over budget rather than truncating. Everything below the header is byte-stable across runs. Resolves supersession like kb_load.",
-  input: import_zod17.z.object({
+  input: import_zod19.z.object({
     bundlePath,
     conceptId,
-    hops: import_zod17.z.number().int().positive().optional().describe("How far from the root the walk may reach. Defaults to 2."),
-    maxNodes: import_zod17.z.number().int().positive().optional().describe(
+    hops: import_zod19.z.number().int().positive().optional().describe("How far from the root the walk may reach. Defaults to 2."),
+    maxNodes: import_zod19.z.number().int().positive().optional().describe(
       "How many records the pack may hold, root included. Defaults to 20."
     ),
-    budgetTokens: import_zod17.z.number().int().positive().optional().describe(
+    budgetTokens: import_zod19.z.number().int().positive().optional().describe(
       "Approximate token ceiling over what is actually emitted. Defaults to 25000."
     )
   }),
@@ -3357,12 +4755,12 @@ var packCommand = define({
     return render3(result, path, now());
   }
 });
-function render3(result, bundle, at) {
+function render3(result, bundle, at2) {
   const lines = [
     `# KB Pack \u2014 ${result.root}`,
     `bundle: ${bundle}`,
     `budget: ~${result.tokensLoaded} of ${result.budgetTokens} tokens, ${result.recordCount} records`,
-    `packed: ${at}`,
+    `packed: ${at2}`,
     "",
     `## Records (${result.records.length})`
   ];
@@ -3419,22 +4817,22 @@ function warningLabel(warning) {
 }
 
 // src/commands/pin.ts
-var import_zod18 = require("zod");
+var import_zod20 = require("zod");
 var pinCommand = define({
   name: "pin",
   tool: "kb_pin",
   usage: "pin [bundle-path] [--mode full|index] [--profiles a,b] [--local|--user] [--frozen|--unfreeze]",
   description: "Pin a base into a workspace manifest so kb_context surfaces it. Layers, nearest wins: project `.strauss/kb-pins.json` (default), `--local` (personal, gitignored), `--user` (`~/.strauss`). Idempotent; `--mode full|index`, `--profiles`, `--frozen`/`--unfreeze` update only those fields. A path with no records pins with a warning. Never touches the base itself.",
-  input: import_zod18.z.object({
+  input: import_zod20.z.object({
     bundlePath,
-    mode: import_zod18.z.enum(["full", "index"]).optional().describe(
+    mode: import_zod20.z.enum(["full", "index"]).optional().describe(
       "full: always emit this base's records whole (still under the block budget); index: never upgrade. Absent: the profile's full-under threshold decides."
     ),
-    profiles: import_zod18.z.array(import_zod18.z.string()).optional().describe("Context profiles this pin surfaces in. Absent: all of them."),
-    layer: import_zod18.z.enum(["project", "local", "user"]).optional().describe(
+    profiles: import_zod20.z.array(import_zod20.z.string()).optional().describe("Context profiles this pin surfaces in. Absent: all of them."),
+    layer: import_zod20.z.enum(["project", "local", "user"]).optional().describe(
       "Which manifest to write: project (committed, default), local (personal, gitignored), user (~/.strauss, every workspace)."
     ),
-    frozen: import_zod18.z.boolean().optional().describe(
+    frozen: import_zod20.z.boolean().optional().describe(
       "true: the base is concluded \u2014 writes against it refuse while pinned. false: lift a freeze."
     )
   }),
@@ -3463,29 +4861,29 @@ var pinCommand = define({
 });
 
 // src/commands/pins.ts
-var import_zod19 = require("zod");
+var import_zod21 = require("zod");
 var pinsCommand = define({
   name: "pins",
   tool: "kb_pins",
   usage: "pins",
   description: "Every pinned base across the manifest layers, with its layer and whether it resolves to records. Takes no bundlePath.",
-  input: import_zod19.z.object({}),
+  input: import_zod21.z.object({}),
   fromArgv: () => ({}),
   run: ({ store }) => listPins(store, process.cwd())
 });
 
 // src/commands/query.ts
-var import_zod20 = require("zod");
+var import_zod22 = require("zod");
 var queryCommand = define({
   name: "query",
   tool: "kb_query",
   usage: "query <text...> [--repo-root PATH]",
   description: "Search; every hit carries its standing. Flagged, never filtered: a superseded hit returns with its replacement, a rejected one is marked. Prefer kb_load when the base fits its budget \u2014 a full read beats search. Results are volatile: place them at the tail, not the cached prefix. Never read record files directly.",
-  input: import_zod20.z.object({
+  input: import_zod22.z.object({
     bundlePath,
-    text: import_zod20.z.string().optional(),
-    type: import_zod20.z.enum(KB_RECORD_TYPES).optional(),
-    includeNonCurrent: import_zod20.z.boolean().optional(),
+    text: import_zod22.z.string().optional(),
+    type: import_zod22.z.enum(KB_RECORD_TYPES).optional(),
+    includeNonCurrent: import_zod22.z.boolean().optional(),
     repoRoot: REPO_ROOT
   }),
   // `--repo-root` is a flag, so its value must not fall into the search text.
@@ -3517,27 +4915,27 @@ var queryCommand = define({
 });
 
 // src/commands/read-index.ts
-var import_zod21 = require("zod");
+var import_zod23 = require("zod");
 var readIndexCommand = define({
   name: "index",
   tool: "kb_index",
   usage: "index",
   description: "The index \u2014 title, type, status, description per record \u2014 rebuilt if stale. Cheapest re-orientation after compaction: call it (or kb_context) first, then kb_load or fetch by id.",
-  input: import_zod21.z.object({ bundlePath }),
+  input: import_zod23.z.object({ bundlePath }),
   fromArgv: (_argv, path) => ({ bundlePath: path }),
   run: ({ store }, { bundlePath: path }) => store.readIndex(path)
 });
 
 // src/commands/schema.ts
-var import_zod24 = require("zod");
+var import_zod26 = require("zod");
 
 // src/json-schema.ts
-var import_zod23 = require("zod");
+var import_zod25 = require("zod");
 
 // src/kb-log.ts
-var import_zod22 = require("zod");
+var import_zod24 = require("zod");
 var LOG_FILE = "log.jsonl";
-var kbLogEntrySchema = import_zod22.z.object({
+var kbLogEntrySchema = import_zod24.z.object({
   // Validated, not just `min(1)`: `at` is a sort key (see `parseLog`
   // below), and a value that isn't actually chronological — a Unix
   // timestamp, a human-typed date, garbage — would sort wrong without
@@ -3546,12 +4944,12 @@ var kbLogEntrySchema = import_zod22.z.object({
   // and rejects everything else, including a non-`Z` offset — so a
   // malformed `at` is reported the same way a malformed line already is,
   // rather than silently sorting into the wrong place.
-  at: import_zod22.z.iso.datetime(),
-  by: import_zod22.z.string().min(1),
-  operation: import_zod22.z.string().min(1),
-  conceptId: import_zod22.z.string().min(1),
+  at: import_zod24.z.iso.datetime(),
+  by: import_zod24.z.string().min(1),
+  operation: import_zod24.z.string().min(1),
+  conceptId: import_zod24.z.string().min(1),
   /** Second concept id, where the operation relates two — supersession. */
-  target: import_zod22.z.string().min(1).optional()
+  target: import_zod24.z.string().min(1).optional()
 }).strict();
 function renderLogEntry(entry) {
   return `${JSON.stringify(kbLogEntrySchema.parse(entry))}
@@ -3561,18 +4959,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);
@@ -3589,11 +4987,11 @@ function parseLog(raw) {
 // src/json-schema.ts
 function kbJsonSchemas() {
   return {
-    recordFrontmatter: import_zod23.z.toJSONSchema(kbRecordFrontmatterSchema, {
+    recordFrontmatter: import_zod25.z.toJSONSchema(kbRecordFrontmatterSchema, {
       io: "input"
     }),
-    composeInput: import_zod23.z.toJSONSchema(composeInputSchema, { io: "input" }),
-    logEntry: import_zod23.z.toJSONSchema(kbLogEntrySchema, { io: "input" })
+    composeInput: import_zod25.z.toJSONSchema(composeInputSchema, { io: "input" }),
+    logEntry: import_zod25.z.toJSONSchema(kbLogEntrySchema, { io: "input" })
   };
 }
 
@@ -3603,25 +5001,25 @@ var schemaCommand = define({
   tool: "kb_schema",
   usage: "schema",
   description: "JSON Schema for frontmatter, write input, and log entries, generated from the enforcing code.",
-  input: import_zod24.z.object({}),
+  input: import_zod26.z.object({}),
   fromArgv: () => ({}),
   run: () => Promise.resolve(kbJsonSchemas())
 });
 
 // src/commands/stamp.ts
-var import_promises5 = require("fs/promises");
-var import_zod25 = require("zod");
+var import_promises8 = require("fs/promises");
+var import_zod27 = require("zod");
 var DIGEST = /^[0-9a-f]{64}$/;
 var stampCommand = define({
   name: "stamp",
   tool: "kb_stamp",
   usage: "stamp [--bundle PATH] [--since DIGEST|FILE]",
-  description: "Content stamp of a base \u2014 `load`'s digest, record counts, per-record digests \u2014 without any bodies. Takes no bundlePath to stamp every pinned base. With `since`, reports only the bases that moved, naming the changed ids when the baseline is a prior stamp; silent when nothing changed. Reads, never writes.",
-  input: import_zod25.z.object({
-    bundlePath: import_zod25.z.string().min(1).optional().describe(
+  description: "Content stamp of a base \u2014 `load`'s digest, record counts, per-record digests, how many records have drifted anchors \u2014 without any bodies. Takes no bundlePath to stamp every pinned base. With `since`, reports only the bases that moved, naming the changed ids. Reads, never writes.",
+  input: import_zod27.z.object({
+    bundlePath: import_zod27.z.string().min(1).optional().describe(
       "Absolute path to one knowledge base. Omit to stamp every pinned base."
     ),
-    since: import_zod25.z.string().min(1).optional().describe(
+    since: import_zod27.z.string().min(1).optional().describe(
       "Prior digest, or path to a prior `stamp --json`; only moved bases return, with changed ids when the baseline is a file."
     )
   }),
@@ -3660,7 +5058,7 @@ var stampCommand = define({
     return reports;
   },
   render: (result) => result.map((report) => {
-    const counts = `${report.recordCount} record(s), ${report.superseded} superseded`;
+    const counts = `${report.recordCount} record(s), ${report.superseded} superseded${report.drifted ? `, ${report.drifted} drifted` : ""}`;
     const head = `${report.path}  ${report.digest}  ${counts}${report.newestAt ? `  newest ${report.newestAt}` : ""}`;
     return report.changed?.length ? `${head}
   changed: ${report.changed.join(", ")}` : head;
@@ -3683,7 +5081,7 @@ async function readBaseline(since) {
   if (DIGEST.test(since)) return { digest: since, byPath: /* @__PURE__ */ new Map() };
   let parsed;
   try {
-    parsed = JSON.parse(await (0, import_promises5.readFile)(since, "utf8"));
+    parsed = JSON.parse(await (0, import_promises8.readFile)(since, "utf8"));
   } catch {
     throw new KbStampBaselineError(since);
   }
@@ -3707,16 +5105,16 @@ async function readBaseline(since) {
 }
 
 // src/commands/status.ts
-var import_zod26 = require("zod");
+var import_zod28 = require("zod");
 var statusCommand = define({
   name: "status",
   tool: "kb_status",
   usage: "status <concept-id> <status>",
   description: "Move a record's status. Compare-and-swap: a concurrent change fails instead of being overwritten.",
-  input: import_zod26.z.object({
+  input: import_zod28.z.object({
     bundlePath,
     conceptId,
-    status: import_zod26.z.enum(KB_RECORD_STATUSES)
+    status: import_zod28.z.enum(KB_RECORD_STATUSES)
   }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
@@ -3731,13 +5129,13 @@ var statusCommand = define({
 });
 
 // src/commands/supersede.ts
-var import_zod27 = require("zod");
+var import_zod29 = require("zod");
 var supersedeCommand = define({
   name: "supersede",
   tool: "kb_supersede",
   usage: "supersede <concept-id> <replacement-id>",
   description: "Mark a record superseded by another, linked in both directions. Use instead of editing a record whose meaning changed.",
-  input: import_zod27.z.object({ bundlePath, conceptId, replacementId: conceptId }),
+  input: import_zod29.z.object({ bundlePath, conceptId, replacementId: conceptId }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
     conceptId: argv[1],
@@ -3751,16 +5149,16 @@ var supersedeCommand = define({
 });
 
 // src/commands/sync-instructions.ts
-var import_zod28 = require("zod");
+var import_zod30 = require("zod");
 var syncInstructionsCommand = define({
   name: "sync-instructions",
   usage: "sync-instructions <file> [--profile NAME] [--budget N] [--full-under N]",
   description: "CLI-only: plant the kb_context block between sentinel comments in AGENTS.md or CLAUDE.md, idempotently.",
-  input: import_zod28.z.object({
-    file: import_zod28.z.string().min(1).describe("The instruction file to edit in place."),
-    budgetTokens: import_zod28.z.number().int().positive().optional(),
-    fullUnderTokens: import_zod28.z.number().int().positive().optional(),
-    profile: import_zod28.z.string().optional()
+  input: import_zod30.z.object({
+    file: import_zod30.z.string().min(1).describe("The instruction file to edit in place."),
+    budgetTokens: import_zod30.z.number().int().positive().optional(),
+    fullUnderTokens: import_zod30.z.number().int().positive().optional(),
+    profile: import_zod30.z.string().optional()
   }),
   fromArgv: (argv) => {
     const budget = argvFlag(argv, "--budget");
@@ -3786,7 +5184,7 @@ var syncInstructionsCommand = define({
 });
 
 // src/commands/trace.ts
-var import_zod29 = require("zod");
+var import_zod31 = require("zod");
 
 // src/trace.ts
 var TRACE_EDGES = [
@@ -3832,8 +5230,8 @@ function trace(seedId, bundle, options = {}) {
   return [...reached.values()].sort(byGeneratedAt);
 }
 function byGeneratedAt(left, right) {
-  const at = (step) => step.record.frontmatter.generated?.at ?? "";
-  return at(left).localeCompare(at(right)) || left.depth - right.depth;
+  const at2 = (step) => step.record.frontmatter.generated?.at ?? "";
+  return at2(left).localeCompare(at2(right)) || left.depth - right.depth;
 }
 
 // src/commands/trace.ts
@@ -3842,11 +5240,11 @@ var traceCommand = define({
   tool: "kb_trace",
   usage: "trace <concept-id> [edges...]",
   description: 'Timeline of how a position was reached, ordered by write time, following supersession, shared anchors and shared sources. Includes rejected, draft and superseded records \u2014 in a history they are the content. For "why is it like this"; kb_load answers "what holds now".',
-  input: import_zod29.z.object({
+  input: import_zod31.z.object({
     bundlePath,
     conceptId,
-    edges: import_zod29.z.array(import_zod29.z.enum(TRACE_EDGES)).optional(),
-    depth: import_zod29.z.number().int().positive().optional()
+    edges: import_zod31.z.array(import_zod31.z.enum(TRACE_EDGES)).optional(),
+    depth: import_zod31.z.number().int().positive().optional()
   }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
@@ -3868,37 +5266,37 @@ var traceCommand = define({
 });
 
 // src/commands/types.ts
-var import_zod30 = require("zod");
+var import_zod32 = require("zod");
 var typesCommand = define({
   name: "types",
   tool: "kb_types",
   usage: "types",
   description: "The twelve record types with their purpose, body sections, and starting status. Read this before writing rather than guessing headings \u2014 a section the type does not define is rejected.",
-  input: import_zod30.z.object({}),
+  input: import_zod32.z.object({}),
   fromArgv: () => ({}),
   run: () => Promise.resolve(RECORD_TYPES)
 });
 
 // src/commands/unpin.ts
-var import_zod31 = require("zod");
+var import_zod33 = require("zod");
 var unpinCommand = define({
   name: "unpin",
   tool: "kb_unpin",
   usage: "unpin [bundle-path]",
   description: "Remove a base from every manifest layer that holds it. Reports the layers touched.",
-  input: import_zod31.z.object({ bundlePath }),
+  input: import_zod33.z.object({ bundlePath }),
   fromArgv: (argv, path) => ({ bundlePath: argv[1] ?? path }),
   run: (_ctx, { bundlePath: path }) => unpinBase(process.cwd(), path)
 });
 
 // src/commands/validate.ts
-var import_zod32 = require("zod");
+var import_zod34 = require("zod");
 var validateCommand = define({
   name: "validate",
   tool: "kb_validate",
   usage: "validate",
   description: "Check pointers no single record can see: supersession links that disagree between the two records, typed causal links, and assumptions that cite sources. Each finding carries a severity: errors fail the exit code, warnings do not.",
-  input: import_zod32.z.object({ bundlePath }),
+  input: import_zod34.z.object({ bundlePath }),
   fromArgv: (_argv, path) => ({ bundlePath: path }),
   run: async ({ store }, { bundlePath: path }) => validateBundle(await store.list(path)),
   // Warnings never fail the exit code; every other severity does.
@@ -3908,16 +5306,16 @@ var validateCommand = define({
 });
 
 // src/commands/verify.ts
-var import_zod33 = require("zod");
+var import_zod35 = require("zod");
 var verifyCommand = define({
   name: "verify",
   tool: "kb_verify",
   usage: "verify <concept-id> --note <text>",
   description: "Append a verified[] event: who checked, when, and what was found. Append-only. A record's own generator is refused unless the actor is `human:`-prefixed.",
-  input: import_zod33.z.object({
+  input: import_zod35.z.object({
     bundlePath,
     conceptId,
-    note: import_zod33.z.string().refine((s) => s.trim().length > 0, {
+    note: import_zod35.z.string().refine((s) => s.trim().length > 0, {
       message: "note must say what the check found"
     })
   }),
@@ -3937,15 +5335,15 @@ var verifyCommand = define({
 });
 
 // src/commands/write.ts
-var import_zod34 = require("zod");
+var import_zod36 = require("zod");
 var writeCommand = define({
   name: "write",
   tool: "kb_write",
   usage: "write <type> < record.json",
   description: "Write one record. Search first \u2014 a duplicate concept id is rejected, not overwritten; kb_types lists each type's sections. An unsourced claim is an `assumption` with assumption: true, never a vague `fact`. Conflicting records get a `risk`, `open-question`, or superseding `decision`. Prefer a new short record over overloading one. Never delete; supersede.",
-  input: import_zod34.z.object({
+  input: import_zod36.z.object({
     bundlePath,
-    type: import_zod34.z.enum(KB_RECORD_TYPES),
+    type: import_zod36.z.enum(KB_RECORD_TYPES),
     input: composeInputSchema
   }),
   fromArgv: async (argv, path, stdin) => ({
@@ -3969,13 +5367,13 @@ var writeCommand = define({
 });
 
 // src/commands/write-decision.ts
-var import_zod35 = require("zod");
+var import_zod37 = require("zod");
 var writeDecisionCommand = define({
   name: "write-decision",
   tool: "kb_write_decision",
   usage: "write-decision < decision.json",
   description: "Write a decision, with `alternative` (what was rejected and why) and `impact` as fields. Record one when a later reader would otherwise simplify the constraint away; skip when the diff already answers it. `sources` for material read, `anchors` for code, `relatedConceptIds` for records.",
-  input: import_zod35.z.object({ bundlePath, input: decisionInputSchema }),
+  input: import_zod37.z.object({ bundlePath, input: decisionInputSchema }),
   fromArgv: async (_argv, path, stdin) => ({
     bundlePath: path,
     input: JSON.parse(await stdin())
@@ -4005,6 +5403,7 @@ var KB_COMMANDS = [
   answerCommand,
   verifyCommand,
   anchorResolveCommand,
+  reassessCommand,
   loadCommand,
   catalogCommand,
   packCommand,
@@ -4031,8 +5430,8 @@ var KB_COMMANDS_BY_NAME = new Map(
 );
 
 // src/kb-store.ts
-var import_promises7 = require("fs/promises");
-var import_node_path8 = require("path");
+var import_promises10 = require("fs/promises");
+var import_node_path11 = require("path");
 
 // src/markdown.ts
 var import_gray_matter = __toESM(require("gray-matter"), 1);
@@ -4060,15 +5459,15 @@ function parseMarkdownWithFrontmatter(text, schema) {
 }
 
 // src/kb-stamp.ts
-var import_node_crypto2 = require("crypto");
-function sha256(contents) {
-  return (0, import_node_crypto2.createHash)("sha256").update(contents).digest("hex");
+var import_node_crypto4 = require("crypto");
+function sha2563(contents) {
+  return (0, import_node_crypto4.createHash)("sha256").update(contents).digest("hex");
 }
 function bundleStamp(records, superseded) {
   const entries = [
     ...records.map((hit) => ({
       conceptId: hit.record.conceptId,
-      digest: `current:${sha256(
+      digest: `current:${sha2563(
         stringifyMarkdownWithFrontmatter(
           hit.record.body,
           hit.record.frontmatter
@@ -4077,11 +5476,11 @@ function bundleStamp(records, superseded) {
     })),
     ...superseded.map((entry) => ({
       conceptId: entry.conceptId,
-      digest: `superseded:${sha256(JSON.stringify(entry))}`
+      digest: `superseded:${sha2563(JSON.stringify(entry))}`
     }))
   ].sort((a, b) => a.conceptId < b.conceptId ? -1 : 1);
   return {
-    digest: sha256(
+    digest: sha2563(
       entries.map((entry) => `${entry.conceptId}:${entry.digest}`).join("\n")
     ),
     records: entries
@@ -4092,8 +5491,8 @@ function bundleDigest(records, superseded) {
 }
 
 // src/search-index.ts
-var import_promises6 = require("fs/promises");
-var import_node_path7 = require("path");
+var import_promises9 = require("fs/promises");
+var import_node_path10 = require("path");
 var SEARCH_INDEX_FILE = ".index.sqlite";
 var COLLECTION = "kb";
 async function searchBase(bundlePath2, query, options = {}) {
@@ -4102,7 +5501,7 @@ async function searchBase(bundlePath2, query, options = {}) {
   let store = null;
   try {
     store = await qmd.createStore({
-      dbPath: (0, import_node_path7.join)(bundlePath2, SEARCH_INDEX_FILE),
+      dbPath: (0, import_node_path10.join)(bundlePath2, SEARCH_INDEX_FILE),
       config: {
         collections: {
           [COLLECTION]: {
@@ -4137,7 +5536,7 @@ async function searchBase(bundlePath2, query, options = {}) {
   }
 }
 async function isStale(bundlePath2) {
-  const indexAt = await (0, import_promises6.stat)((0, import_node_path7.join)(bundlePath2, SEARCH_INDEX_FILE)).then((s) => s.mtimeMs).catch(() => 0);
+  const indexAt = await (0, import_promises9.stat)((0, import_node_path10.join)(bundlePath2, SEARCH_INDEX_FILE)).then((s) => s.mtimeMs).catch(() => 0);
   if (!indexAt) return true;
   const { readdir: readdir2 } = await import("fs/promises");
   const names = (await readdir2(bundlePath2).catch(() => [])).filter(
@@ -4146,8 +5545,8 @@ async function isStale(bundlePath2) {
   let stale = false;
   await mapLimit(names, DEFAULT_IO_CONCURRENCY, async (name) => {
     if (stale) return;
-    const at = await (0, import_promises6.stat)((0, import_node_path7.join)(bundlePath2, name)).then((s) => s.mtimeMs).catch(() => 0);
-    if (at > indexAt) stale = true;
+    const at2 = await (0, import_promises9.stat)((0, import_node_path10.join)(bundlePath2, name)).then((s) => s.mtimeMs).catch(() => 0);
+    if (at2 > indexAt) stale = true;
   });
   return stale;
 }
@@ -4260,8 +5659,8 @@ function byRank(left, right) {
   ) || left.record.conceptId.localeCompare(right.record.conceptId);
 }
 function typeRank(record) {
-  const index = TYPE_PRIORITY.indexOf(record.frontmatter.type);
-  return index === -1 ? TYPE_PRIORITY.length : index;
+  const index2 = TYPE_PRIORITY.indexOf(record.frontmatter.type);
+  return index2 === -1 ? TYPE_PRIORITY.length : index2;
 }
 
 // src/kb-links/inbound.ts
@@ -4424,7 +5823,7 @@ function appendUnionMergeLine(contents) {
 }
 
 // src/kb-store.ts
-var KB_DIR = (0, import_node_path8.join)(".strauss", "kb");
+var KB_DIR = (0, import_node_path11.join)(".strauss", "kb");
 var STORE_OWNED = /* @__PURE__ */ new Set([INDEX_FILE, LOG_FILE, SEARCH_INDEX_FILE]);
 var DEFAULT_LOAD_BUDGET = 25e3;
 var KbStore = class {
@@ -4455,7 +5854,7 @@ var KbStore = class {
     const conceptId2 = `${input.type}.${input.slug}`;
     const root = this.root(bundlePath2);
     const target = this.recordPath(bundlePath2, conceptId2);
-    await (0, import_promises7.mkdir)(root, { recursive: true });
+    await (0, import_promises10.mkdir)(root, { recursive: true });
     await this.publish(
       target,
       stringifyMarkdownWithFrontmatter(input.body, frontmatter),
@@ -4494,7 +5893,7 @@ var KbStore = class {
     const target = this.recordPath(bundlePath2, conceptId2);
     let raw;
     try {
-      raw = await (0, import_promises7.readFile)(target, "utf8");
+      raw = await (0, import_promises10.readFile)(target, "utf8");
     } catch {
       return null;
     }
@@ -4511,7 +5910,7 @@ var KbStore = class {
     const root = this.root(bundlePath2);
     let names;
     try {
-      names = await (0, import_promises7.readdir)(root);
+      names = await (0, import_promises10.readdir)(root);
     } catch {
       return [];
     }
@@ -4519,7 +5918,7 @@ var KbStore = class {
     const records = await mapLimit(
       wanted,
       DEFAULT_IO_CONCURRENCY,
-      async ({ name, conceptId: conceptId2 }) => this.parse(conceptId2, await (0, import_promises7.readFile)((0, import_node_path8.join)(root, name), "utf8"))
+      async ({ name, conceptId: conceptId2 }) => this.parse(conceptId2, await (0, import_promises10.readFile)((0, import_node_path11.join)(root, name), "utf8"))
     );
     return records.filter((record) => record !== null);
   }
@@ -4567,8 +5966,8 @@ var KbStore = class {
    * and the refusal is logged under its own operation name — `mutate` only
    * logs what it publishes.
    */
-  async verify(bundlePath2, conceptId2, note, actor = "unknown", at = (/* @__PURE__ */ new Date()).toISOString()) {
-    const event = kbVerifiedEventSchema.parse({ by: actor, at, note });
+  async verify(bundlePath2, conceptId2, note, actor = "unknown", at2 = (/* @__PURE__ */ new Date()).toISOString()) {
+    const event = kbVerifiedEventSchema.parse({ by: actor, at: at2, note });
     const existing = await this.read(bundlePath2, conceptId2);
     if (!existing) throw new KbRecordNotFoundError(conceptId2);
     const generatedBy = existing.frontmatter.generated?.by;
@@ -4620,14 +6019,14 @@ var KbStore = class {
     return superseded;
   }
   /** Resolves an open question, stamping who answered and when. */
-  async answer(bundlePath2, conceptId2, answer, actor = "unknown", at = (/* @__PURE__ */ new Date()).toISOString()) {
+  async answer(bundlePath2, conceptId2, answer, actor = "unknown", at2 = (/* @__PURE__ */ new Date()).toISOString()) {
     return this.mutate(
       bundlePath2,
       conceptId2,
       (frontmatter) => ({
         ...frontmatter,
         strauss_status: "resolved",
-        strauss_answered: { by: actor, at }
+        strauss_answered: { by: actor, at: at2 }
       }),
       { operation: "answer", by: actor },
       (body) => `${body.trimEnd()}
@@ -4676,7 +6075,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
@@ -4796,24 +6195,34 @@ ${answer}
   }
   /**
    * `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.
+   * the same way, handed back as a stamp.
+   *
+   * Drift is counted but kept out of the digest, which is what lets the reload
+   * hook ask one question and get two answers: whether the base moved, and
+   * whether the code under it did. A `load` and a `stamp` of the same base
+   * still agree on the digest, because no warning has ever reached it.
    */
-  async stamp(bundlePath2) {
+  async stamp(bundlePath2, options = {}) {
     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();
+    const dates = bundle.map((record) => record.frontmatter.generated?.at ?? null).filter((at2) => typeof at2 === "string").sort();
+    const drift = await this.detectDrift(bundle, options.repoRoot);
+    const drifted2 = drift === void 0 ? null : [...drift.values()].filter(
+      (entries) => entries.some(
+        (entry) => entry.state !== "match" && !isUncheckedReason(entry.reason)
+      )
+    ).length;
     return {
       path: bundlePath2,
       digest: stamped.digest,
       recordCount: bundle.length,
       superseded: superseded.length,
       newestAt: dates.at(-1) ?? null,
-      records: stamped.records
+      records: stamped.records,
+      drifted: drifted2
     };
   }
   /** How a position was arrived at, as a timeline. See `trace.ts`. */
@@ -4846,11 +6255,11 @@ ${answer}
   async readIndex(bundlePath2) {
     const root = this.root(bundlePath2);
     const expected = renderIndex(await this.list(bundlePath2));
-    const stored = await (0, import_promises7.readFile)((0, import_node_path8.join)(root, INDEX_FILE), "utf8").catch(
+    const stored = await (0, import_promises10.readFile)((0, import_node_path11.join)(root, INDEX_FILE), "utf8").catch(
       () => null
     );
     if (indexIsStale(stored, expected)) {
-      await this.publish((0, import_node_path8.join)(root, INDEX_FILE), expected, true, INDEX_FILE);
+      await this.publish((0, import_node_path11.join)(root, INDEX_FILE), expected, true, INDEX_FILE);
       this.logger.info?.({
         operation: "kb.index.repair",
         bundlePath: root,
@@ -4867,8 +6276,8 @@ ${answer}
    * knows which agent touched what. So a bad line is surfaced and left alone.
    */
   async readLog(bundlePath2) {
-    const raw = await (0, import_promises7.readFile)(
-      (0, import_node_path8.join)(this.root(bundlePath2), LOG_FILE),
+    const raw = await (0, import_promises10.readFile)(
+      (0, import_node_path11.join)(this.root(bundlePath2), LOG_FILE),
       "utf8"
     ).catch(() => "");
     const result = parseLog(raw);
@@ -4919,15 +6328,15 @@ ${answer}
   }
   async mutate(bundlePath2, conceptId2, change, entry, changeBody = (body) => body) {
     const target = this.recordPath(bundlePath2, conceptId2);
-    const before = await (0, import_promises7.readFile)(target, "utf8").catch(() => null);
+    const before = await (0, import_promises10.readFile)(target, "utf8").catch(() => null);
     if (before === null) throw new KbRecordNotFoundError(conceptId2);
     const parsed = this.parse(conceptId2, before);
     if (!parsed) throw new KbRecordNotFoundError(conceptId2);
     const frontmatter = change(parsed.frontmatter);
     const body = changeBody(parsed.body);
     const contents = stringifyMarkdownWithFrontmatter(body, frontmatter);
-    const witness = await (0, import_promises7.readFile)(target, "utf8").catch(() => null);
-    if (witness === null || sha256(witness) !== sha256(before)) {
+    const witness = await (0, import_promises10.readFile)(target, "utf8").catch(() => null);
+    if (witness === null || sha2563(witness) !== sha2563(before)) {
       throw new KbWriteConflictError(conceptId2);
     }
     await this.publish(target, contents, true, conceptId2);
@@ -4952,20 +6361,20 @@ ${answer}
    */
   async publish(target, contents, overwrite, conceptId2) {
     const staging = `${target}.${process.pid}.tmp`;
-    await (0, import_promises7.writeFile)(staging, contents, "utf8");
+    await (0, import_promises10.writeFile)(staging, contents, "utf8");
     try {
       if (overwrite) {
-        await (0, import_promises7.rename)(staging, target);
+        await (0, import_promises10.rename)(staging, target);
         return;
       }
-      await (0, import_promises7.link)(staging, target);
+      await (0, import_promises10.link)(staging, target);
     } catch (error) {
       if (error.code === "EEXIST") {
         throw new KbRecordAlreadyExistsError(conceptId2);
       }
       throw error;
     } finally {
-      await (0, import_promises7.unlink)(staging).catch(() => void 0);
+      await (0, import_promises10.unlink)(staging).catch(() => void 0);
     }
   }
   /**
@@ -5009,18 +6418,18 @@ ${answer}
    * file must not fail the mutation it guards.
    */
   async ensureGitattributes(root) {
-    const target = (0, import_node_path8.join)(root, GITATTRIBUTES_FILE);
+    const target = (0, import_node_path11.join)(root, GITATTRIBUTES_FILE);
     try {
       let existing;
       try {
-        existing = await (0, import_promises7.readFile)(target, "utf8");
+        existing = await (0, import_promises10.readFile)(target, "utf8");
       } catch (error) {
         if (error.code !== "ENOENT") throw error;
         existing = null;
       }
       if (existing === null) {
         try {
-          await (0, import_promises7.writeFile)(target, appendUnionMergeLine(""), {
+          await (0, import_promises10.writeFile)(target, appendUnionMergeLine(""), {
             encoding: "utf8",
             flag: "wx"
           });
@@ -5041,7 +6450,7 @@ ${answer}
         return;
       }
       if (!hasMergeDeclaration(existing)) {
-        await (0, import_promises7.appendFile)(target, appendUnionMergeLine(existing), "utf8");
+        await (0, import_promises10.appendFile)(target, appendUnionMergeLine(existing), "utf8");
         this.logger.info?.({
           operation: "kb.gitattributes.ensure",
           bundlePath: root,
@@ -5060,7 +6469,7 @@ ${answer}
   async record(root, entry) {
     await this.ensureGitattributes(root);
     const line = renderLogEntry({ at: (/* @__PURE__ */ new Date()).toISOString(), ...entry });
-    await (0, import_promises7.appendFile)((0, import_node_path8.join)(root, LOG_FILE), line, "utf8").catch((error) => {
+    await (0, import_promises10.appendFile)((0, import_node_path11.join)(root, LOG_FILE), line, "utf8").catch((error) => {
       this.logger.warn?.({
         operation: "kb.log.append",
         outcome: "failed",
@@ -5086,18 +6495,18 @@ ${answer}
     };
   }
   root(bundlePath2) {
-    return (0, import_node_path8.resolve)(bundlePath2);
+    return (0, import_node_path11.resolve)(bundlePath2);
   }
   // Concept ids are `<type>.<slug>` and map to a single file directly under the
   // bundle root; anything carrying a separator would escape it.
   recordPath(bundlePath2, conceptId2) {
-    if (conceptId2.includes(import_node_path8.sep) || conceptId2.includes("/")) {
+    if (conceptId2.includes(import_node_path11.sep) || conceptId2.includes("/")) {
       throw new KbInvalidConceptIdError(
         "concept id must not contain a path separator",
         { conceptId: conceptId2 }
       );
     }
-    return (0, import_node_path8.join)(this.root(bundlePath2), `${conceptId2}.md`);
+    return (0, import_node_path11.join)(this.root(bundlePath2), `${conceptId2}.md`);
   }
 };
 function estimateTokens(record) {
@@ -5124,7 +6533,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)
@@ -5137,7 +6546,7 @@ function normalizeActor(id) {
 }
 
 // src/version.ts
-var VERSION = true ? "0.1.16" : "0.0.0-dev";
+var VERSION = true ? "0.1.18" : "0.0.0-dev";
 
 // src/mcp.ts
 function createKbMcpServer() {