@saasontools/strauss-kb 0.1.10 → 0.1.12

package/dist/cli-main.cjs

@@ -24,7 +24,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/cli.ts
-var import_node_path7 = require("path");
+var import_node_path8 = require("path");
 
 // src/decision-record.ts
 var import_zod3 = require("zod");
@@ -52,7 +52,31 @@ var kbVerifiedEventSchema = kbActorStampSchema.extend({
 });
 var kbAnchorSchema = import_zod.z.object({
   file: import_zod.z.string().min(1),
-  symbol: import_zod.z.string().min(1).optional()
+  symbol: import_zod.z.string().min(1).optional(),
+  /**
+   * Which repository the file lives in — a remote URL
+   * (`https://github.com/org/name`) or a short name. Absent means the base's
+   * own repository, which is what nearly every anchor means.
+   *
+   * Unvalidated beyond not-blank: one repository has many spellings.
+   * Matched after normalisation; see ARCHITECTURE.
+   */
+  repo: import_zod.z.string().trim().min(1).optional(),
+  /**
+   * The git rev the evidence was taken at. Prefer a commit SHA: a branch
+   * name is a moving pointer, so an anchor pinned to one says the evidence
+   * came from wherever that branch happens to be now, which is not a
+   * baseline. Recorded and preserved in v1; ref-pinned reads land with
+   * SAA-709.
+   */
+  ref: import_zod.z.string().trim().min(1).optional(),
+  hash: import_zod.z.string().regex(/^sha256:[0-9a-f]{64}$/, {
+    message: "hash must be sha256:<64 hex chars>"
+  }).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()
 }).strict();
 var KB_RECORD_TYPES = [
   "fact",
@@ -319,9 +343,596 @@ function composeNoDecisionRecord(reason, writtenBy, writtenAt) {
   );
 }
 
-// src/commands/answer.ts
+// src/commands/anchor-resolve.ts
 var import_zod6 = require("zod");
 
+// src/anchor-resolver.ts
+var import_node_child_process = require("child_process");
+var import_node_crypto = require("crypto");
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+var import_node_util = require("util");
+
+// src/concurrency.ts
+var DEFAULT_IO_CONCURRENCY = 16;
+async function mapLimit(items, limit, fn) {
+  if (!Number.isInteger(limit) || limit < 1) {
+    throw new RangeError(
+      `mapLimit: "limit" must be a positive integer, got ${limit}`
+    );
+  }
+  const out = new Array(items.length);
+  let next = 0;
+  let failed = false;
+  const runners = Array.from(
+    { length: Math.min(limit, items.length) },
+    async () => {
+      while (!failed && next < items.length) {
+        const at = next++;
+        try {
+          out[at] = await fn(items[at], at);
+        } catch (error) {
+          failed = true;
+          throw error;
+        }
+      }
+    }
+  );
+  await Promise.all(runners);
+  return out;
+}
+
+// src/anchor-resolver.ts
+var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
+var MAX_ANCHOR_FILE_BYTES = 1048576;
+var PARENT_SCOPE_LINES = 50;
+var CLEAN_STATE = { blockComment: false, template: false };
+function stripLine(line, state) {
+  let out = "";
+  let index = 0;
+  let { blockComment, template } = state;
+  while (index < line.length) {
+    const char = line[index];
+    const next = line[index + 1];
+    if (blockComment) {
+      if (char === "*" && next === "/") {
+        blockComment = false;
+        index += 2;
+        continue;
+      }
+      index += 1;
+      continue;
+    }
+    if (template) {
+      if (char === "\\") {
+        index += 2;
+        continue;
+      }
+      if (char === "`") template = false;
+      index += 1;
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      blockComment = true;
+      index += 2;
+      continue;
+    }
+    if (char === "/" && next === "/") break;
+    if (char === "`") {
+      template = true;
+      index += 1;
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      const quote = char;
+      index += 1;
+      while (index < line.length) {
+        if (line[index] === "\\") {
+          index += 2;
+          continue;
+        }
+        if (line[index] === quote) {
+          index += 1;
+          break;
+        }
+        index += 1;
+      }
+      continue;
+    }
+    out += char;
+    index += 1;
+  }
+  return { code: out, state: { blockComment, template } };
+}
+function span(lines, from, to) {
+  return {
+    text: lines.slice(from, to + 1).join("\n"),
+    startLine: from + 1,
+    endLine: to + 1
+  };
+}
+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);
+    state = stripped.state;
+    for (const char of stripped.code) {
+      if (char === "{") {
+        depth += 1;
+        opened = true;
+      } else if (char === "}") {
+        depth = Math.max(0, depth - 1);
+      } else if (char === ";" && !opened) {
+        return span(lines, matchLine, index);
+      }
+    }
+    if (opened && depth === 0) return span(lines, matchLine, index);
+  }
+  return null;
+}
+var PYTHON_HEADER = /^\s*(?:async\s+)?(?:def|class)\s+[A-Za-z_]\w*\s*[(:]/;
+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();
+    if (code.endsWith(":")) {
+      headerEnd = index;
+      break;
+    }
+    if (code.includes(":")) return span(lines, matchLine, index);
+  }
+  if (headerEnd === -1) return null;
+  let end = headerEnd;
+  for (let index = headerEnd + 1; index < lines.length; index++) {
+    const line = lines[index] ?? "";
+    if (line.trim() === "") continue;
+    const lineIndent = line.length - line.trimStart().length;
+    if (lineIndent <= indent) break;
+    end = index;
+  }
+  return end === headerEnd ? null : span(lines, matchLine, end);
+}
+var TIERS = [
+  (name) => new RegExp(
+    `(?:function|class|interface|type|enum|const|let|var|def)\\s+${name}\\b`
+  ),
+  (name) => new RegExp(`\\b${name}\\s*[:=]`),
+  (name) => new RegExp(`\\b${name}\\s*\\(`),
+  (name) => new RegExp(`\\b${name}\\b`)
+];
+var regexResolver = {
+  name: "regex",
+  resolve(source, symbol) {
+    const segments = symbol.split(".");
+    const name = segments[segments.length - 1];
+    if (!name) return null;
+    const parent = segments.length > 1 ? segments[segments.length - 2] : void 0;
+    const escaped = escapeRegExp(name);
+    const parentPattern = parent ? new RegExp(`\\b${escapeRegExp(parent)}\\b`) : null;
+    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);
+      if (!candidates.length) continue;
+      if (parentPattern && candidates.length > 1) {
+        const distances = candidates.map(
+          (index) => distanceToParent(lines, index, parentPattern)
+        );
+        const nearest = Math.min(...distances);
+        if (Number.isFinite(nearest)) {
+          candidates = candidates.filter((_, at) => distances[at] === nearest);
+        }
+      }
+      if (candidates.length !== 1) return null;
+      const matchLine = candidates[0];
+      return PYTHON_HEADER.test(lines[matchLine] ?? "") ? captureIndentedBlock(lines, matchLine) : captureBraceBlock(lines, matchLine);
+    }
+    return null;
+  }
+};
+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;
+  }
+  return Number.POSITIVE_INFINITY;
+}
+function hashAnchorText(text) {
+  return `sha256:${(0, import_node_crypto.createHash)("sha256").update(text.replace(/\r\n/g, "\n")).digest("hex")}`;
+}
+function resolveAnchor(source, anchor, resolver = 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)
+    };
+  }
+  return resolver.resolve(normalized, anchor.symbol);
+}
+function anchorFilePath(repoRoot, file) {
+  const path = (0, import_node_path.resolve)(repoRoot, file.replace(/^\.\//, ""));
+  const rel = (0, import_node_path.relative)((0, import_node_path.resolve)(repoRoot), path);
+  if (rel === "" || rel === ".." || rel.startsWith(`..${import_node_path.sep}`) || (0, import_node_path.isAbsolute)(rel)) {
+    return null;
+  }
+  return path;
+}
+function contains(root, path) {
+  const rel = (0, import_node_path.relative)(root, path);
+  return rel !== "" && rel !== ".." && !rel.startsWith(`..${import_node_path.sep}`) && !(0, import_node_path.isAbsolute)(rel);
+}
+function normalizeRepoUrl(value) {
+  let url = value.trim().replace(/^git\+/, "");
+  const scp = /^[\w.-]+@([\w.-]+):(.+)$/.exec(url);
+  if (scp) url = `https://${scp[1]}/${scp[2]}`;
+  url = url.replace(/^ssh:\/\/(?:[^@/]+@)?/, "https://");
+  url = trimTrailingSlashes(url);
+  if (url.endsWith(".git")) url = url.slice(0, -4);
+  return trimTrailingSlashes(url).toLowerCase();
+}
+function trimTrailingSlashes(value) {
+  let end = value.length;
+  while (end > 0 && value[end - 1] === "/") end -= 1;
+  return value.slice(0, end);
+}
+function repoPath(normalized) {
+  const withoutScheme = normalized.replace(/^[a-z0-9+.-]+:\/\//, "");
+  const segments = withoutScheme.split("/").filter(Boolean);
+  return segments.length > 1 ? segments.slice(1).join("/") : "";
+}
+function repoIdentifies(declared, originUrl) {
+  if (!originUrl) return false;
+  const origin = normalizeRepoUrl(originUrl);
+  const want = normalizeRepoUrl(declared);
+  if (!want || !origin) return false;
+  if (want === origin) return true;
+  const path = repoPath(origin);
+  if (!path) return false;
+  return want === path || want === (path.split("/").pop() ?? "");
+}
+async function repoOriginUrl(repoRoot) {
+  try {
+    const { stdout } = await execFileAsync(
+      "git",
+      ["-C", repoRoot, "config", "--get", "remote.origin.url"],
+      { timeout: 5e3 }
+    );
+    return stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+var LazyOrigin = class {
+  constructor(repoRoot) {
+    this.repoRoot = repoRoot;
+  }
+  repoRoot;
+  url = null;
+  asked = false;
+  /** Asks git once, so later `isForeign` calls need no await. */
+  async prime() {
+    if (this.asked) return;
+    this.url = await repoOriginUrl(this.repoRoot);
+    this.asked = true;
+  }
+  /** Only meaningful after `prime`; an unprimed origin identifies nothing. */
+  isForeign(anchor) {
+    if (!anchor.repo) return false;
+    return !repoIdentifies(anchor.repo, this.url);
+  }
+  async foreign(anchor) {
+    if (!anchor.repo) return false;
+    await this.prime();
+    return this.isForeign(anchor);
+  }
+};
+function errorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error ? String(error.code) : void 0;
+}
+function anchorFileReader(repoRoot) {
+  let rootOnce;
+  const realRoot = () => {
+    rootOnce ??= (0, import_promises.realpath)((0, import_node_path.resolve)(repoRoot)).catch((error) => {
+      rootOnce = void 0;
+      throw error;
+    });
+    return rootOnce;
+  };
+  return (file) => readAnchorFileWithRoot(repoRoot, file, realRoot);
+}
+async function readAnchorFileWithRoot(repoRoot, file, realRoot) {
+  const lexical = anchorFilePath(repoRoot, file);
+  if (lexical === null) return { ok: false, reason: "outside-repo" };
+  let root;
+  let path;
+  try {
+    root = await realRoot();
+    path = await (0, import_promises.realpath)(lexical);
+  } catch (error) {
+    const code = errorCode(error);
+    if (code === "ENOENT" || code === "ENOTDIR") {
+      return { ok: false, reason: "file-missing" };
+    }
+    return { ok: false, reason: "file-unreadable" };
+  }
+  if (!contains(root, path)) return { ok: false, reason: "outside-repo" };
+  try {
+    const stats = await (0, import_promises.stat)(path);
+    if (!stats.isFile()) return { ok: false, reason: "file-unreadable" };
+    if (stats.size > MAX_ANCHOR_FILE_BYTES) {
+      return { ok: false, reason: "file-too-large" };
+    }
+    return { ok: true, source: await (0, import_promises.readFile)(path, "utf8") };
+  } catch (error) {
+    const code = errorCode(error);
+    if (code === "ENOENT" || code === "ENOTDIR") {
+      return { ok: false, reason: "file-missing" };
+    }
+    return { ok: false, reason: "file-unreadable" };
+  }
+}
+function looksLikeWrongRepoRoot(drift) {
+  let checked = 0;
+  for (const entries of drift.values()) {
+    for (const entry of entries) {
+      if (entry.reason === "foreign-repo") continue;
+      checked += 1;
+      if (entry.state !== "unresolved" || entry.reason !== "file-missing") {
+        return false;
+      }
+    }
+  }
+  return checked > 0;
+}
+async function readAnchorFiles(files, read, concurrency = DEFAULT_IO_CONCURRENCY) {
+  if (!Number.isInteger(concurrency) || concurrency < 1) {
+    throw new RangeError(
+      `readAnchorFiles: option "concurrency" must be a positive integer, got ${concurrency}`
+    );
+  }
+  const wanted = [...new Set(files)];
+  const results = await mapLimit(wanted, concurrency, async (file) => {
+    try {
+      return await read(file);
+    } catch {
+      return { ok: false, reason: "file-unreadable" };
+    }
+  });
+  return new Map(wanted.map((file, at) => [file, results[at]]));
+}
+async function detectAnchorDrift(records, options = {}) {
+  const repoRoot = options.repoRoot ?? process.cwd();
+  const resolver = options.resolver ?? regexResolver;
+  const origin = new LazyOrigin(repoRoot);
+  const planned = /* @__PURE__ */ new Map();
+  let declaresRepo = false;
+  for (const record of records) {
+    const anchors = (record.frontmatter.strauss_anchors ?? []).filter(
+      (anchor) => anchor.hash
+    );
+    if (!anchors.length) continue;
+    if (anchors.some((anchor) => anchor.repo)) declaresRepo = true;
+    planned.set(
+      record.conceptId,
+      anchors.map((anchor) => ({ anchor, foreign: false }))
+    );
+  }
+  if (declaresRepo) {
+    await origin.prime();
+    for (const entries of planned.values()) {
+      for (const entry of entries)
+        entry.foreign = origin.isForeign(entry.anchor);
+    }
+  }
+  const files = [];
+  for (const entries of planned.values()) {
+    for (const entry of entries) {
+      if (!entry.foreign) files.push(entry.anchor.file);
+    }
+  }
+  const reads = await readAnchorFiles(
+    files,
+    options.reader ?? anchorFileReader(repoRoot),
+    options.concurrency ?? DEFAULT_IO_CONCURRENCY
+  );
+  const drift = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    const entries = [];
+    for (const { anchor, foreign } of planned.get(record.conceptId) ?? []) {
+      const base = {
+        file: anchor.file,
+        ...anchor.symbol ? { symbol: anchor.symbol } : {},
+        storedHash: anchor.hash
+      };
+      if (foreign) {
+        entries.push({
+          ...base,
+          state: "unresolved",
+          diffSize: null,
+          reason: "foreign-repo"
+        });
+        continue;
+      }
+      const read = reads.get(anchor.file);
+      if (!read.ok) {
+        entries.push({
+          ...base,
+          state: "unresolved",
+          diffSize: null,
+          reason: read.reason
+        });
+        continue;
+      }
+      const resolved = resolveAnchor(read.source, anchor, resolver);
+      if (!resolved) {
+        entries.push({
+          ...base,
+          state: "unresolved",
+          diffSize: null,
+          reason: "symbol-not-found"
+        });
+        continue;
+      }
+      const currentHash = hashAnchorText(resolved.text);
+      const currentLines = resolved.endLine - resolved.startLine + 1;
+      entries.push({
+        ...base,
+        state: currentHash === anchor.hash ? "match" : "drifted",
+        currentHash,
+        diffSize: anchor.lines === void 0 ? null : Math.abs(currentLines - anchor.lines)
+      });
+    }
+    if (entries.length) drift.set(record.conceptId, entries);
+  }
+  return drift;
+}
+
+// src/errors.ts
+var BaseError = class extends Error {
+  code;
+  errorType;
+  fault;
+  retriable;
+  reportToUser;
+  details;
+  constructor(props) {
+    super(props.message);
+    this.name = props.name ?? this.constructor.name;
+    this.code = props.code ?? 500;
+    this.errorType = props.errorType;
+    this.fault = props.fault;
+    this.retriable = props.retriable ?? true;
+    this.reportToUser = props.reportToUser ?? false;
+    this.details = props.details;
+  }
+};
+
+// src/kb-errors.ts
+var KbRecordAlreadyExistsError = class extends BaseError {
+  constructor(conceptId2) {
+    super({
+      message: `kb: ${conceptId2} already exists \u2014 choose a more specific slug, or write with overwrite`,
+      errorType: "KbRecordAlreadyExists" /* KbRecordAlreadyExists */,
+      code: 409,
+      fault: "User" /* User */,
+      retriable: false,
+      reportToUser: true,
+      details: { conceptId: conceptId2, action: "refused" }
+    });
+    this.conceptId = conceptId2;
+  }
+  conceptId;
+};
+var KbRecordNotFoundError = class extends BaseError {
+  constructor(conceptId2) {
+    super({
+      message: `kb: ${conceptId2} does not exist`,
+      errorType: "KbRecordNotFound" /* KbRecordNotFound */,
+      code: 404,
+      fault: "User" /* User */,
+      retriable: false,
+      reportToUser: true,
+      details: { conceptId: conceptId2 }
+    });
+    this.conceptId = conceptId2;
+  }
+  conceptId;
+};
+var KbWriteConflictError = class extends BaseError {
+  constructor(conceptId2) {
+    super({
+      message: `kb: ${conceptId2} changed while it was being updated \u2014 re-read and retry`,
+      errorType: "KbWriteConflict" /* KbWriteConflict */,
+      code: 409,
+      fault: "System" /* System */,
+      retriable: true,
+      reportToUser: true,
+      details: { conceptId: conceptId2 }
+    });
+    this.conceptId = conceptId2;
+  }
+  conceptId;
+};
+var KbSelfVerificationError = class extends BaseError {
+  constructor(conceptId2, actor, generatedBy) {
+    super({
+      message: `kb: ${conceptId2} was generated by ${generatedBy}, and a record's generator cannot verify it \u2014 only a human or a different actor can`,
+      errorType: "KbSelfVerification" /* KbSelfVerification */,
+      code: 400,
+      fault: "User" /* User */,
+      retriable: false,
+      reportToUser: true,
+      details: { conceptId: conceptId2, actor, generatedBy, action: "refused" }
+    });
+    this.conceptId = conceptId2;
+    this.actor = actor;
+    this.generatedBy = generatedBy;
+  }
+  conceptId;
+  actor;
+  generatedBy;
+};
+var KbPackBudgetExceededError = class extends BaseError {
+  constructor(recordCount, approxTokens2, budgetTokens, excluded) {
+    super({
+      message: `kb: a pack of ${recordCount} records is ~${approxTokens2} tokens against a budget of ${budgetTokens} \u2014 lower hops or maxNodes, or raise the budget`,
+      errorType: "KbPackBudgetExceeded" /* KbPackBudgetExceeded */,
+      code: 400,
+      fault: "User" /* User */,
+      retriable: false,
+      reportToUser: true,
+      details: { recordCount, approxTokens: approxTokens2, budgetTokens, excluded }
+    });
+    this.recordCount = recordCount;
+    this.approxTokens = approxTokens2;
+    this.budgetTokens = budgetTokens;
+    this.excluded = excluded;
+  }
+  recordCount;
+  approxTokens;
+  budgetTokens;
+  excluded;
+};
+var KbMissingFlagValueError = class extends BaseError {
+  constructor(flag) {
+    super({
+      message: `kb: ${flag} needs a value \u2014 pass ${flag} <value> or ${flag}=<value>`,
+      errorType: "KbMissingFlagValue" /* KbMissingFlagValue */,
+      code: 400,
+      fault: "User" /* User */,
+      retriable: false,
+      reportToUser: true,
+      details: { flag }
+    });
+    this.flag = flag;
+  }
+  flag;
+};
+var KbInvalidConceptIdError = class extends BaseError {
+  constructor(message, details) {
+    super({
+      message: `kb: ${message}`,
+      errorType: "KbInvalidConceptId" /* KbInvalidConceptId */,
+      code: 400,
+      fault: "User" /* User */,
+      retriable: false,
+      reportToUser: true,
+      details
+    });
+  }
+};
+
 // src/kb-pins/budgets.ts
 function asBudgets(value) {
   if (value === null || typeof value !== "object") return {};
@@ -371,18 +982,18 @@ var KbBaseFrozenError = class extends Error {
 };
 
 // src/kb-pins/frozen.ts
-var import_node_path3 = require("path");
+var import_node_path4 = require("path");
 
 // src/kb-pins/layers.ts
-var import_promises = require("fs/promises");
+var import_promises2 = require("fs/promises");
 var import_node_os = require("os");
-var import_node_path2 = require("path");
+var import_node_path3 = require("path");
 
 // src/kb-pins/model.ts
-var import_node_path = require("path");
+var import_node_path2 = require("path");
 var import_zod4 = require("zod");
-var PINS_FILE = (0, import_node_path.join)(".strauss", "kb-pins.json");
-var PINS_LOCAL_FILE = (0, import_node_path.join)(".strauss", "kb-pins.local.json");
+var PINS_FILE = (0, import_node_path2.join)(".strauss", "kb-pins.json");
+var PINS_LOCAL_FILE = (0, import_node_path2.join)(".strauss", "kb-pins.local.json");
 var PIN_LAYERS = ["project", "local", "user"];
 var pinSchema = import_zod4.z.object({
   /** Relative to the manifest's root, so the file is committable. */
@@ -432,10 +1043,10 @@ function userRoot() {
   return process.env.STRAUSS_KB_USER_ROOT || (0, import_node_os.homedir)();
 }
 function layerRoot(workspaceDir, layer) {
-  return layer === "user" ? userRoot() : (0, import_node_path2.resolve)(workspaceDir);
+  return layer === "user" ? userRoot() : (0, import_node_path3.resolve)(workspaceDir);
 }
 function layerFile(workspaceDir, layer) {
-  return (0, import_node_path2.join)(
+  return (0, import_node_path3.join)(
     layerRoot(workspaceDir, layer),
     layer === "local" ? PINS_LOCAL_FILE : PINS_FILE
   );
@@ -444,7 +1055,7 @@ async function readPinsLayer(workspaceDir, layer) {
   const file = layerFile(workspaceDir, layer);
   let raw;
   try {
-    raw = await (0, import_promises.readFile)(file, "utf8");
+    raw = await (0, import_promises2.readFile)(file, "utf8");
   } catch {
     return { pins: [] };
   }
@@ -468,16 +1079,16 @@ async function readPinsLayer(workspaceDir, layer) {
 }
 async function writePinsLayer(workspaceDir, layer, manifest) {
   const file = layerFile(workspaceDir, layer);
-  await (0, import_promises.mkdir)((0, import_node_path2.dirname)(file), { recursive: true });
-  await (0, import_promises.writeFile)(file, `${JSON.stringify(manifest, null, 2)}
+  await (0, import_promises2.mkdir)((0, import_node_path3.dirname)(file), { recursive: true });
+  await (0, import_promises2.writeFile)(file, `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
 }
 function resolvePinPath(rootDir, path) {
-  return (0, import_node_path2.isAbsolute)(path) ? (0, import_node_path2.resolve)(path) : (0, import_node_path2.resolve)(rootDir, path.split("/").join(import_node_path2.sep));
+  return (0, import_node_path3.isAbsolute)(path) ? (0, import_node_path3.resolve)(path) : (0, import_node_path3.resolve)(rootDir, path.split("/").join(import_node_path3.sep));
 }
 function storablePath(rootDir, bundlePath2) {
-  const rel = (0, import_node_path2.relative)((0, import_node_path2.resolve)(rootDir), (0, import_node_path2.resolve)(bundlePath2));
-  return (rel === "" ? "." : rel).split(import_node_path2.sep).join("/");
+  const rel = (0, import_node_path3.relative)((0, import_node_path3.resolve)(rootDir), (0, import_node_path3.resolve)(bundlePath2));
+  return (rel === "" ? "." : rel).split(import_node_path3.sep).join("/");
 }
 async function readMergedPins(workspaceDir) {
   const manifests = {};
@@ -505,7 +1116,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_path3.resolve)(bundlePath2);
+  const absolute = (0, import_node_path4.resolve)(bundlePath2);
   const pin = merged.pins.find((entry) => entry.absolutePath === absolute);
   if (pin?.frozen === true) {
     throw new KbBaseFrozenError(pin.path, pin.layer);
@@ -546,218 +1157,84 @@ async function pinBase(store, workspaceDir, bundlePath2, at, options = {}) {
   const warning = records.length === 0 ? `no records found at ${absolute} \u2014 pinned anyway; bases are routinely pinned before they are populated` : void 0;
   const fields = {
     ...options.mode ? { mode: options.mode } : {},
-    ...options.profiles?.length ? { profiles: options.profiles } : {},
-    ...options.frozen !== void 0 ? { frozen: options.frozen } : {}
-  };
-  if (existing) {
-    const updated = { ...existing, ...fields };
-    if (Object.keys(fields).length) {
-      await writePinsLayer(workspaceDir, layer, {
-        ...manifest,
-        pins: manifest.pins.map(
-          (entry2) => entry2 === existing ? updated : entry2
-        )
-      });
-    }
-    return {
-      path: existing.path,
-      layer,
-      pinnedAt: existing.pinnedAt ?? at,
-      alreadyPinned: true,
-      ...updated.mode ? { mode: updated.mode } : {},
-      ...updated.profiles ? { profiles: updated.profiles } : {},
-      ...updated.frozen !== void 0 ? { frozen: updated.frozen } : {},
-      ...warning ? { warning } : {}
-    };
-  }
-  const entry = {
-    path: storablePath(root, bundlePath2),
-    pinnedAt: at,
-    ...fields
-  };
-  await writePinsLayer(workspaceDir, layer, {
-    ...manifest,
-    pins: [...manifest.pins, entry]
-  });
-  return {
-    path: entry.path,
-    layer,
-    pinnedAt: at,
-    alreadyPinned: false,
-    ...fields,
-    ...warning ? { warning } : {}
-  };
-}
-
-// src/kb-pins/unpin.ts
-var import_node_path4 = require("path");
-async function unpinBase(workspaceDir, bundlePath2) {
-  const layers = [];
-  for (const layer of PIN_LAYERS) {
-    const root = layerRoot(workspaceDir, layer);
-    let manifest;
-    try {
-      manifest = await readPinsLayer(workspaceDir, layer);
-    } catch {
-      continue;
-    }
-    const absolute = resolvePinPath(root, storablePath(root, bundlePath2));
-    const kept = manifest.pins.filter(
-      (entry) => resolvePinPath(root, entry.path) !== absolute
-    );
-    if (kept.length !== manifest.pins.length) {
-      await writePinsLayer(workspaceDir, layer, { ...manifest, pins: kept });
-      layers.push(layer);
-    }
-  }
-  return {
-    path: storablePath((0, import_node_path4.resolve)(workspaceDir), bundlePath2),
-    removed: layers.length > 0,
-    layers
-  };
-}
-
-// src/commands/model.ts
-var import_zod5 = require("zod");
-
-// src/errors.ts
-var BaseError = class extends Error {
-  code;
-  errorType;
-  fault;
-  retriable;
-  reportToUser;
-  details;
-  constructor(props) {
-    super(props.message);
-    this.name = props.name ?? this.constructor.name;
-    this.code = props.code ?? 500;
-    this.errorType = props.errorType;
-    this.fault = props.fault;
-    this.retriable = props.retriable ?? true;
-    this.reportToUser = props.reportToUser ?? false;
-    this.details = props.details;
-  }
-};
-
-// src/kb-errors.ts
-var KbRecordAlreadyExistsError = class extends BaseError {
-  constructor(conceptId2) {
-    super({
-      message: `kb: ${conceptId2} already exists \u2014 choose a more specific slug, or write with overwrite`,
-      errorType: "KbRecordAlreadyExists" /* KbRecordAlreadyExists */,
-      code: 409,
-      fault: "User" /* User */,
-      retriable: false,
-      reportToUser: true,
-      details: { conceptId: conceptId2, action: "refused" }
-    });
-    this.conceptId = conceptId2;
-  }
-  conceptId;
-};
-var KbRecordNotFoundError = class extends BaseError {
-  constructor(conceptId2) {
-    super({
-      message: `kb: ${conceptId2} does not exist`,
-      errorType: "KbRecordNotFound" /* KbRecordNotFound */,
-      code: 404,
-      fault: "User" /* User */,
-      retriable: false,
-      reportToUser: true,
-      details: { conceptId: conceptId2 }
-    });
-    this.conceptId = conceptId2;
-  }
-  conceptId;
-};
-var KbWriteConflictError = class extends BaseError {
-  constructor(conceptId2) {
-    super({
-      message: `kb: ${conceptId2} changed while it was being updated \u2014 re-read and retry`,
-      errorType: "KbWriteConflict" /* KbWriteConflict */,
-      code: 409,
-      fault: "System" /* System */,
-      retriable: true,
-      reportToUser: true,
-      details: { conceptId: conceptId2 }
-    });
-    this.conceptId = conceptId2;
-  }
-  conceptId;
-};
-var KbSelfVerificationError = class extends BaseError {
-  constructor(conceptId2, actor, generatedBy) {
-    super({
-      message: `kb: ${conceptId2} was generated by ${generatedBy}, and a record's generator cannot verify it \u2014 only a human or a different actor can`,
-      errorType: "KbSelfVerification" /* KbSelfVerification */,
-      code: 400,
-      fault: "User" /* User */,
-      retriable: false,
-      reportToUser: true,
-      details: { conceptId: conceptId2, actor, generatedBy, action: "refused" }
-    });
-    this.conceptId = conceptId2;
-    this.actor = actor;
-    this.generatedBy = generatedBy;
-  }
-  conceptId;
-  actor;
-  generatedBy;
-};
-var KbPackBudgetExceededError = class extends BaseError {
-  constructor(recordCount, approxTokens2, budgetTokens, excluded) {
-    super({
-      message: `kb: a pack of ${recordCount} records is ~${approxTokens2} tokens against a budget of ${budgetTokens} \u2014 lower hops or maxNodes, or raise the budget`,
-      errorType: "KbPackBudgetExceeded" /* KbPackBudgetExceeded */,
-      code: 400,
-      fault: "User" /* User */,
-      retriable: false,
-      reportToUser: true,
-      details: { recordCount, approxTokens: approxTokens2, budgetTokens, excluded }
-    });
-    this.recordCount = recordCount;
-    this.approxTokens = approxTokens2;
-    this.budgetTokens = budgetTokens;
-    this.excluded = excluded;
-  }
-  recordCount;
-  approxTokens;
-  budgetTokens;
-  excluded;
-};
-var KbMissingFlagValueError = class extends BaseError {
-  constructor(flag) {
-    super({
-      message: `kb: ${flag} needs a value \u2014 pass ${flag} <value> or ${flag}=<value>`,
-      errorType: "KbMissingFlagValue" /* KbMissingFlagValue */,
-      code: 400,
-      fault: "User" /* User */,
-      retriable: false,
-      reportToUser: true,
-      details: { flag }
-    });
-    this.flag = flag;
+    ...options.profiles?.length ? { profiles: options.profiles } : {},
+    ...options.frozen !== void 0 ? { frozen: options.frozen } : {}
+  };
+  if (existing) {
+    const updated = { ...existing, ...fields };
+    if (Object.keys(fields).length) {
+      await writePinsLayer(workspaceDir, layer, {
+        ...manifest,
+        pins: manifest.pins.map(
+          (entry2) => entry2 === existing ? updated : entry2
+        )
+      });
+    }
+    return {
+      path: existing.path,
+      layer,
+      pinnedAt: existing.pinnedAt ?? at,
+      alreadyPinned: true,
+      ...updated.mode ? { mode: updated.mode } : {},
+      ...updated.profiles ? { profiles: updated.profiles } : {},
+      ...updated.frozen !== void 0 ? { frozen: updated.frozen } : {},
+      ...warning ? { warning } : {}
+    };
   }
-  flag;
-};
-var KbInvalidConceptIdError = class extends BaseError {
-  constructor(message, details) {
-    super({
-      message: `kb: ${message}`,
-      errorType: "KbInvalidConceptId" /* KbInvalidConceptId */,
-      code: 400,
-      fault: "User" /* User */,
-      retriable: false,
-      reportToUser: true,
-      details
-    });
+  const entry = {
+    path: storablePath(root, bundlePath2),
+    pinnedAt: at,
+    ...fields
+  };
+  await writePinsLayer(workspaceDir, layer, {
+    ...manifest,
+    pins: [...manifest.pins, entry]
+  });
+  return {
+    path: entry.path,
+    layer,
+    pinnedAt: at,
+    alreadyPinned: false,
+    ...fields,
+    ...warning ? { warning } : {}
+  };
+}
+
+// src/kb-pins/unpin.ts
+var import_node_path5 = require("path");
+async function unpinBase(workspaceDir, bundlePath2) {
+  const layers = [];
+  for (const layer of PIN_LAYERS) {
+    const root = layerRoot(workspaceDir, layer);
+    let manifest;
+    try {
+      manifest = await readPinsLayer(workspaceDir, layer);
+    } catch {
+      continue;
+    }
+    const absolute = resolvePinPath(root, storablePath(root, bundlePath2));
+    const kept = manifest.pins.filter(
+      (entry) => resolvePinPath(root, entry.path) !== absolute
+    );
+    if (kept.length !== manifest.pins.length) {
+      await writePinsLayer(workspaceDir, layer, { ...manifest, pins: kept });
+      layers.push(layer);
+    }
   }
-};
+  return {
+    path: storablePath((0, import_node_path5.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(
+  "Where the anchored source lives, for the drift check. Defaults to the working directory."
+);
 function define(command) {
   return command;
 }
@@ -777,13 +1254,175 @@ function argvFlag(argv, name) {
   return value;
 }
 
+// src/commands/anchor-resolve.ts
+var anchorResolveCommand = define({
+  name: "anchor-resolve",
+  tool: "kb_anchor_resolve",
+  usage: "anchor-resolve <concept-id> [--repo-root <path>] [--rebaseline] [--restamp]",
+  description: "Resolve a record's anchors against the working tree: stamp a hash onto anchors that lack one, report drift where the code moved. kb_verify's mechanical counterpart \u2014 reach for it when the question is whether the code still is what it was, not whether the claim still holds. Anchors naming another repository are skipped. Exits non-zero on drift.",
+  input: import_zod6.z.object({
+    bundlePath,
+    conceptId,
+    repoRoot: import_zod6.z.string().min(1).optional(),
+    rebaseline: import_zod6.z.boolean().optional().describe(
+      "Accept the current code as the new baseline for anchors that drifted."
+    ),
+    restamp: import_zod6.z.boolean().optional().describe(
+      "Refresh `resolved_at` on anchors that already match. Off by default, so a green run writes nothing."
+    )
+  }),
+  fromArgv: (argv, path) => ({
+    bundlePath: path,
+    conceptId: argv[1],
+    repoRoot: argvFlag(argv, "--repo-root"),
+    rebaseline: argv.includes("--rebaseline"),
+    restamp: argv.includes("--restamp")
+  }),
+  run: async ({ store, actor, now }, { bundlePath: path, conceptId: id, repoRoot, rebaseline, restamp }) => {
+    const root = repoRoot ?? process.cwd();
+    const record = await store.read(path, id);
+    if (!record) throw new KbRecordNotFoundError(id);
+    const anchors = record.frontmatter.strauss_anchors ?? [];
+    if (!anchors.length) {
+      return {
+        conceptId: id,
+        results: [],
+        verified: false,
+        note: "record has no anchors"
+      };
+    }
+    const results = [];
+    const updated = [];
+    const origin = new LazyOrigin(root);
+    let dirty = false;
+    if (anchors.some((anchor) => anchor.repo)) await origin.prime();
+    const foreign = new Map(
+      anchors.map((anchor) => [anchor, origin.isForeign(anchor)])
+    );
+    const reads = await readAnchorFiles(
+      anchors.filter((anchor) => !foreign.get(anchor)).map((anchor) => anchor.file),
+      anchorFileReader(root)
+    );
+    for (const anchor of anchors) {
+      const base = {
+        file: anchor.file,
+        ...anchor.symbol ? { symbol: anchor.symbol } : {},
+        // Carried onto unresolved findings too: an anchor that once hashed
+        // and now resolves to nothing is a broken anchor, and the exit code
+        // has to be able to tell it from one nobody ever stamped.
+        ...anchor.hash ? { storedHash: anchor.hash } : {}
+      };
+      if (foreign.get(anchor)) {
+        results.push({ ...base, state: "unresolved", reason: "foreign-repo" });
+        updated.push(anchor);
+        continue;
+      }
+      const fileRead = reads.get(anchor.file);
+      if (!fileRead.ok) {
+        results.push({ ...base, state: "unresolved", reason: fileRead.reason });
+        updated.push(anchor);
+        continue;
+      }
+      const resolved = resolveAnchor(fileRead.source, anchor);
+      if (!resolved) {
+        results.push({
+          ...base,
+          state: "unresolved",
+          reason: "symbol-not-found"
+        });
+        updated.push(anchor);
+        continue;
+      }
+      const currentHash = hashAnchorText(resolved.text);
+      const currentLines = resolved.endLine - resolved.startLine + 1;
+      const stamped = {
+        ...anchor,
+        hash: currentHash,
+        lines: currentLines,
+        resolved_at: now()
+      };
+      if (!anchor.hash) {
+        results.push({ ...base, state: "stamped", currentHash });
+        updated.push(stamped);
+        dirty = true;
+      } else if (anchor.hash === currentHash) {
+        results.push({
+          ...base,
+          state: "match",
+          currentHash
+        });
+        const refresh = restamp || anchor.resolved_at === void 0;
+        updated.push(refresh ? { ...anchor, resolved_at: now() } : anchor);
+        if (refresh) dirty = true;
+      } else {
+        results.push({
+          ...base,
+          state: "drifted",
+          currentHash,
+          diffSize: anchor.lines === void 0 ? null : Math.abs(currentLines - anchor.lines),
+          ...rebaseline ? { rebaselined: true } : {}
+        });
+        updated.push(rebaseline ? stamped : anchor);
+        if (rebaseline) dirty = true;
+      }
+    }
+    let frozen = false;
+    if (dirty) {
+      try {
+        await assertBaseNotFrozen(process.cwd(), path);
+      } catch (error) {
+        if (!(error instanceof KbBaseFrozenError)) throw error;
+        frozen = true;
+      }
+      if (!frozen) await store.updateAnchors(path, id, updated, actor);
+    }
+    const frozenNote = frozen ? { frozen: true, note: "base is frozen: nothing was stamped" } : {};
+    const checked = results.filter((entry) => entry.reason !== "foreign-repo");
+    const skipped = results.length - checked.length;
+    const matches2 = checked.filter((entry) => entry.state === "match").length;
+    const clean = checked.length > 0 && checked.every((entry) => entry.state === "match");
+    if (clean) {
+      try {
+        await store.verify(
+          path,
+          id,
+          `anchor-resolve: ${matches2}/${checked.length} anchors match${skipped ? `, ${skipped} in another repo` : ""} (regex resolver)`,
+          actor,
+          now()
+        );
+      } catch (error) {
+        if (!(error instanceof KbSelfVerificationError)) throw error;
+        return {
+          conceptId: id,
+          results,
+          verified: false,
+          verifyRefused: "self-verification",
+          ...frozenNote
+        };
+      }
+      return { conceptId: id, results, verified: true, ...frozenNote };
+    }
+    return { conceptId: id, results, verified: false, ...frozenNote };
+  },
+  // A stored hash that no longer resolves is a broken anchor, not an absence:
+  // the file was deleted or the symbol renamed, and exiting zero on it would
+  // let the one edit that destroys an anchor pass the gate that exists to
+  // catch it. An anchor nobody ever stamped is still just unstamped, and one
+  // belonging to another repository was never this run's to check — failing CI
+  // on either would gate on work this command did not do.
+  failsWhen: (result) => result.results.some(
+    (entry) => entry.state === "drifted" || entry.state === "unresolved" && entry.storedHash !== void 0 && entry.reason !== "foreign-repo"
+  )
+});
+
 // src/commands/answer.ts
+var import_zod7 = require("zod");
 var answerCommand = define({
   name: "answer",
   tool: "kb_answer",
   usage: "answer <concept-id> <answer...>",
   description: "Resolve an open question: sets the status, stamps who answered and when, and appends an Answer section. If the answer overturns an assumption or a decision, that is a supersession \u2014 do it explicitly.",
-  input: import_zod6.z.object({ bundlePath, conceptId, answer: import_zod6.z.string().min(1) }),
+  input: import_zod7.z.object({ bundlePath, conceptId, answer: import_zod7.z.string().min(1) }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
     conceptId: argv[1],
@@ -797,7 +1436,7 @@ var answerCommand = define({
 });
 
 // src/commands/catalog.ts
-var import_zod7 = require("zod");
+var import_zod8 = require("zod");
 
 // src/adjudicate.ts
 var STANDING = {
@@ -809,7 +1448,7 @@ var STANDING = {
   rejected: "rejected",
   superseded: "superseded"
 };
-function adjudicate(hits, bundle, now = /* @__PURE__ */ new Date()) {
+function adjudicate(hits, bundle, now = /* @__PURE__ */ new Date(), anchorDrift) {
   const byId = new Map(bundle.map((record) => [record.conceptId, record]));
   return hits.map((record) => {
     const status = record.frontmatter.strauss_status;
@@ -839,6 +1478,20 @@ function adjudicate(hits, bundle, now = /* @__PURE__ */ new Date()) {
     if (!record.frontmatter.verified?.length) {
       warnings.push({ kind: "unverified" });
     }
+    const moved = (anchorDrift?.get(record.conceptId) ?? []).filter(
+      (entry) => entry.state !== "match" && entry.reason !== "foreign-repo"
+    );
+    if (moved.length) {
+      warnings.push({
+        kind: "drifted",
+        anchors: moved.map(({ file, symbol, diffSize, reason }) => ({
+          file,
+          ...symbol !== void 0 ? { symbol } : {},
+          diffSize,
+          ...reason !== void 0 ? { reason } : {}
+        }))
+      });
+    }
     return { record, standing: STANDING[status], heads, warnings };
   });
 }
@@ -943,9 +1596,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_zod7.z.object({
+  input: import_zod8.z.object({
     bundlePath,
-    type: import_zod7.z.enum(KB_RECORD_TYPES).optional()
+    type: import_zod8.z.enum(KB_RECORD_TYPES).optional()
   }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
@@ -1000,10 +1653,10 @@ function count(value, noun) {
 }
 
 // src/commands/context.ts
-var import_zod8 = require("zod");
+var import_zod9 = require("zod");
 
 // src/kb-context.ts
-var import_promises2 = require("fs/promises");
+var import_promises3 = require("fs/promises");
 
 // src/kb-index.ts
 var INDEX_FILE = "INDEX.md";
@@ -1230,13 +1883,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_promises2.readFile)(file, "utf8").catch(() => null);
+  const existing = await (0, import_promises3.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_promises2.writeFile)(file, `${region}
+    await (0, import_promises3.writeFile)(file, `${region}
 `, "utf8");
     return { file, action: "created" };
   }
@@ -1247,11 +1900,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_promises2.writeFile)(file, next, "utf8");
+    await (0, import_promises3.writeFile)(file, next, "utf8");
     return { file, action: region ? "replaced" : "removed" };
   }
   if (!region) return { file, action: "unchanged" };
-  await (0, import_promises2.writeFile)(
+  await (0, import_promises3.writeFile)(
     file,
     `${existing.replace(/\n*$/, "\n\n")}${region}
 `,
@@ -1266,20 +1919,20 @@ var contextCommand = define({
   tool: "kb_context",
   usage: "context [--profile NAME] [--budget N] [--full-under N] [--format json] [--event NAME]",
   description: "The pinned-base index block, for injection at every context birth \u2014 startup, clear, resume, and after compaction. An index, not the content: concept ids, titles and standing, with the bodies left behind kb_load at the point of use. Emits nothing when nothing is pinned. Refuses with the list of bases and their sizes rather than truncating past its budget. Budgets resolve most-specific-first: explicit flags, then the workspace manifests' `context` tables (per profile, over their `default`), then the built-in profile (session-start, compact, turn), then package defaults \u2014 so a repo tunes its own numbers in .strauss/kb-pins.json without touching hook commands. Like kb_schema and kb_types this takes no bundlePath \u2014 it reads the workspace pin manifests, because which bases a session should see is workspace state, not a property of one base.",
-  input: import_zod8.z.object({
-    budgetTokens: import_zod8.z.number().int().positive().optional().describe(
+  input: import_zod9.z.object({
+    budgetTokens: import_zod9.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_zod8.z.number().int().positive().optional().describe(
+    fullUnderTokens: import_zod9.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_zod8.z.string().optional().describe(
+    profile: import_zod9.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_zod8.z.enum(["markdown", "json"]).optional().describe(
+    format: import_zod9.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_zod8.z.string().optional().describe(
+    event: import_zod9.z.string().optional().describe(
       "hookEventName stamped into the JSON envelope. Only meaningful with format=json."
     )
   }),
@@ -1315,7 +1968,7 @@ var contextCommand = define({
 });
 
 // src/commands/doctor.ts
-var import_zod9 = require("zod");
+var import_zod10 = require("zod");
 
 // src/kb-edges.ts
 var KB_EDGE_KINDS = [
@@ -1439,7 +2092,8 @@ var CHECK_HEADLINES = {
   aging: "still open or still proposed long after it was written",
   orphaned: "no other record links to it",
   "broken-supersession": "the supersession pointers do not resolve",
-  "superseded-but-cited": "a live record's body links to one that no longer holds"
+  "superseded-but-cited": "a live record's body links to one that no longer holds",
+  drifted: "the code an anchor points at moved out from under its hash"
 };
 var DAY_MS = 864e5;
 function doctor(bundle, options = {}) {
@@ -1449,7 +2103,7 @@ function doctor(bundle, options = {}) {
     agingDays: options.agingDays ?? DEFAULT_AGING_DAYS
   };
   const now = options.now ?? /* @__PURE__ */ new Date();
-  const adjudicated = adjudicate(bundle, bundle, now);
+  const adjudicated = adjudicate(bundle, bundle, now, options.anchorDrift);
   const standings = new Map(
     adjudicated.map((hit) => [hit.record.conceptId, hit.standing])
   );
@@ -1463,7 +2117,8 @@ function doctor(bundle, options = {}) {
     group("aging", aging(inForce, now, thresholds.agingDays)),
     group("orphaned", orphaned(bundle)),
     group("broken-supersession", brokenSupersession(bundle, adjudicated)),
-    group("superseded-but-cited", supersededButCited(bundle, standings))
+    group("superseded-but-cited", supersededButCited(bundle, standings)),
+    group("drifted", drifted(inForce))
   ];
   const counts = Object.fromEntries(
     groups.map((entry) => [entry.check, entry.count])
@@ -1649,6 +2304,29 @@ function supersededButCited(bundle, standings) {
   }
   return findings;
 }
+function drifted(hits) {
+  const findings = [];
+  for (const hit of hits) {
+    const warning = hit.warnings.find((entry) => entry.kind === "drifted");
+    if (!warning) continue;
+    findings.push(
+      finding(
+        hit.record,
+        `${warning.anchors.length} ${warning.anchors.length === 1 ? "anchor no longer matches" : "anchors no longer match"}: ${warning.anchors.map((anchor) => {
+          const at = anchor.symbol ? `${anchor.file}:${anchor.symbol}` : anchor.file;
+          if (anchor.reason) return `${at} (${anchor.reason})`;
+          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)`;
+        }).join(", ")}`
+      )
+    );
+  }
+  return findings.sort(
+    (left, right) => left.conceptId.localeCompare(right.conceptId)
+  );
+}
 function replaces(later, earlier) {
   return (later.frontmatter.strauss_supersedes ?? []).includes(earlier.conceptId) || earlier.frontmatter.strauss_superseded_by === later.conceptId;
 }
@@ -1672,14 +2350,15 @@ function ageInDays(record, now) {
 }
 
 // src/commands/doctor.ts
-var days = (what, fallback) => import_zod9.z.number().int().positive().optional().describe(`${what} Defaults to ${fallback}.`);
+var days = (what, fallback) => import_zod10.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] [--strict]",
-  description: "A health sweep over a whole base: what the calendar has already retired, what nobody ever confirmed, what has been open or proposed long enough that the status is now the answer, and what the graph has dropped on the floor. Read-only \u2014 it never writes, never supersedes, and never re-dates anything; every finding names a record for a person to repair. Seven checks, grouped and counted: expired (past `stale_after`), expiring (inside the window), unverified (an empty `verified[]` on a record old enough to matter), aging (still `open` or `proposed`), orphaned (no other record links to it), broken supersession (a chain that does not resolve), and superseded-but-cited (a live record whose body links to a record that no longer holds). Every group is reported even when empty, because a check that found nothing and a check that never ran look identical in a report that only lists findings.\n\nThis is the question no reader thinks to ask, which is why it needs a command: decay is invisible from inside a single record \u2014 a stale one reads exactly like a live one, and a question nobody answered reads exactly like one nobody asked. Reach for it when picking up a base someone else kept, before trusting a base you have not touched in months, or on a schedule; kb_validate is the narrower neighbour, checking only whether pointers between records agree.",
-  input: import_zod9.z.object({
+  usage: "doctor [--expiring-days N] [--unverified-days N] [--aging-days N] [--repo-root PATH] [--strict]",
+  description: "Read-only health sweep: expired, expiring, unverified, aging, orphaned, broken-supersession, superseded-but-cited, drifted 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_zod10.z.object({
     bundlePath,
+    repoRoot: REPO_ROOT,
     expiringDays: days(
       "How far ahead `expiring` looks, in days.",
       DEFAULT_EXPIRING_DAYS
@@ -1692,7 +2371,7 @@ var doctorCommand = define({
       "How long a record may stay `open` or `proposed` before `aging` reports it, in days.",
       DEFAULT_AGING_DAYS
     ),
-    strict: import_zod9.z.boolean().optional().describe(
+    strict: import_zod10.z.boolean().optional().describe(
       "Turn an expired record into a non-zero exit for the CLI. No effect on the report itself."
     )
   }),
@@ -1704,29 +2383,36 @@ var doctorCommand = define({
     const expiring2 = argvFlag(argv, "--expiring-days");
     const unverified2 = argvFlag(argv, "--unverified-days");
     const agingDays = argvFlag(argv, "--aging-days");
+    const repoRoot = argvFlag(argv, "--repo-root");
     return {
       bundlePath: path,
+      ...repoRoot !== void 0 ? { repoRoot } : {},
       ...expiring2 !== void 0 ? { expiringDays: Number(expiring2) } : {},
       ...unverified2 !== void 0 ? { unverifiedDays: Number(unverified2) } : {},
       ...agingDays !== void 0 ? { agingDays: Number(agingDays) } : {},
       ...argv.includes("--strict") ? { strict: true } : {}
     };
   },
-  run: async ({ store, now }, { bundlePath: path, expiringDays, unverifiedDays, agingDays }) => {
+  run: async ({ store, now }, { bundlePath: path, expiringDays, unverifiedDays, agingDays, repoRoot }) => {
     const checkedAt = now();
-    const report = doctor(await store.list(path), {
+    const records = await store.list(path);
+    const anchorDrift = await store.detectDrift(records, repoRoot);
+    const report = doctor(records, {
       ...expiringDays !== void 0 ? { expiringDays } : {},
       ...unverifiedDays !== void 0 ? { unverifiedDays } : {},
       ...agingDays !== void 0 ? { agingDays } : {},
+      ...anchorDrift !== void 0 ? { anchorDrift } : {},
       now: new Date(checkedAt)
     });
     return { bundlePath: path, checkedAt, ...report };
   },
   render: (result) => render2(result),
-  // Only expiry, and only under --strict. The other six checks report debt a
+  // Only expiry, and only under --strict. The other seven checks report debt a
   // reader decides about; an expired record is the base asserting something it
   // already said it would stop standing behind, which is the one finding a
-  // pipeline can act on without a judgment call.
+  // pipeline can act on without a judgment call. Drift has its own gate —
+  // `anchor-resolve` exits non-zero on it, against a repo root the caller
+  // named, which is the run a CI pipeline should be making anyway.
   failsWhen: (result, input) => input.strict === true && result.counts.expired > 0
 });
 function render2(result) {
@@ -1761,13 +2447,13 @@ function render2(result) {
 }
 
 // src/commands/list.ts
-var import_zod10 = require("zod");
+var import_zod11 = require("zod");
 var listCommand = define({
   name: "list",
   tool: "kb_list",
   usage: "list [type]",
   description: "Every record, optionally narrowed to one type. Use kb_query when you have a question; this is for enumerating.",
-  input: import_zod10.z.object({ bundlePath, type: import_zod10.z.enum(KB_RECORD_TYPES).optional() }),
+  input: import_zod11.z.object({ bundlePath, type: import_zod11.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,
@@ -1779,36 +2465,40 @@ var listCommand = define({
 });
 
 // src/commands/load.ts
-var import_zod11 = require("zod");
+var import_zod12 = require("zod");
 var loadCommand = define({
   name: "load",
   tool: "kb_load",
-  usage: "load [type] [--budget N] [--all]",
-  description: "Loads the whole knowledge base at once, each record with its standing. Superseded records arrive as stubs (name, replacement, date); rejected and open records arrive whole. Refuses past the token budget rather than truncating \u2014 call kb_catalog, then kb_pack on the record that matters, or narrow with `type`; kb_query for a lookup by wording. `all` bypasses the budget.",
-  input: import_zod11.z.object({
+  usage: "load [type] [--budget N | --all] [--repo-root PATH]",
+  description: "Loads the whole knowledge base at once, each record with its standing. Superseded records arrive as stubs; rejected and open records arrive whole. Refuses past the token budget \u2014 call kb_catalog, kb_pack on it; `all` bypasses the budget. Never read record files directly. Cache-stable; `digest` is the base's content stamp \u2014 hooks use it to tell you when to reload.",
+  input: import_zod12.z.object({
     bundlePath,
-    type: import_zod11.z.enum(KB_RECORD_TYPES).optional(),
-    budgetTokens: import_zod11.z.number().int().positive().optional().describe("Approximate token ceiling. Defaults to 25000."),
-    all: import_zod11.z.boolean().optional().describe(
+    type: import_zod12.z.enum(KB_RECORD_TYPES).optional(),
+    budgetTokens: import_zod12.z.number().int().positive().optional().describe("Approximate token ceiling. Defaults to 25000."),
+    all: import_zod12.z.boolean().optional().describe(
       "Loads the entire base regardless of size, bypassing the token budget; mutually exclusive with budgetTokens."
-    )
+    ),
+    repoRoot: REPO_ROOT
   }).refine((value) => !(value.all && value.budgetTokens !== void 0), {
     message: "all is mutually exclusive with budgetTokens: pass a ceiling or none, not both."
   }),
   fromArgv: (argv, path) => {
     const budget = argvFlag(argv, "--budget");
+    const repoRoot = argvFlag(argv, "--repo-root");
     return {
       bundlePath: path,
       ...argv[1] && !argv[1].startsWith("--") ? { type: argv[1] } : {},
       ...budget ? { budgetTokens: Number(budget) } : {},
-      ...argv.includes("--all") ? { all: true } : {}
+      ...argv.includes("--all") ? { all: true } : {},
+      ...repoRoot !== void 0 ? { repoRoot } : {}
     };
   },
-  run: async ({ store }, { bundlePath: path, type, budgetTokens, all }) => {
+  run: async ({ store }, { bundlePath: path, type, budgetTokens, all, repoRoot }) => {
     const result = await store.load(path, {
       ...type ? { type } : {},
       ...budgetTokens ? { budgetTokens } : {},
-      ...all ? { all } : {}
+      ...all ? { all } : {},
+      ...repoRoot !== void 0 ? { repoRoot } : {}
     });
     if (!result.loaded) return result;
     return {
@@ -1827,25 +2517,25 @@ var loadCommand = define({
 });
 
 // src/commands/log.ts
-var import_zod12 = require("zod");
+var import_zod13 = require("zod");
 var logCommand = define({
   name: "log",
   tool: "kb_log",
   usage: "log",
   description: "What touched what, and when. The only artifact here that cannot be reconstructed from the records, so malformed lines are reported rather than repaired.",
-  input: import_zod12.z.object({ bundlePath }),
+  input: import_zod13.z.object({ bundlePath }),
   fromArgv: (_argv, path) => ({ bundlePath: path }),
   run: ({ store }, { bundlePath: path }) => store.readLog(path)
 });
 
 // src/commands/no-decision.ts
-var import_zod13 = require("zod");
+var import_zod14 = require("zod");
 var noDecisionCommand = define({
   name: "no-decision",
   tool: "kb_no_decision",
   usage: "no-decision <reason...>",
   description: 'Claim in one sentence that there was nothing to decide. Gating on "did you write a decision?" rewards writing a junk one; gating on "did you answer?" does not, so silence has to be expressible. Idempotent \u2014 restating it is not a collision.',
-  input: import_zod13.z.object({ bundlePath, reason: import_zod13.z.string().min(1) }),
+  input: import_zod14.z.object({ bundlePath, reason: import_zod14.z.string().min(1) }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
     reason: argv.slice(1).join(" ").trim()
@@ -1862,20 +2552,20 @@ var noDecisionCommand = define({
 });
 
 // src/commands/pack.ts
-var import_zod14 = require("zod");
+var import_zod15 = require("zod");
 var packCommand = define({
   name: "pack",
   tool: "kb_pack",
   usage: "pack <conceptId> [--hops N] [--max-nodes N] [--budget N]",
   description: "The bounded neighbourhood around one record: everything within `hops` of the root, ranked and cut to `maxNodes`, with every cut record named under Excluded \u2014 a named gap is knowable, a silent one is not. Prefer this over kb_load when the base is too large to hold whole and the work centres on one record; prefer it over kb_query when the question needs the governed neighbourhood \u2014 what was settled and what binds near this record \u2014 rather than a lookup by wording. Superseded records arrive as name, replacement and date stubs exactly as kb_load emits them: their bodies no longer hold, and kb_trace has the history. Refuses outright rather than truncating when the pack would exceed its token budget \u2014 a partial pack is indistinguishable from a complete one \u2014 reporting the record count and every already-cut id so the caller can lower hops or maxNodes, or raise the budget. The header carries the bundle, root, budget and a timestamp; everything below the header is byte-identical across runs over an unchanged base, so two packs can be diffed and a changed byte means changed knowledge. This tool (with kb_load, kb_query and kb_trace) is the only supported way to read a base; a raw file read bypasses supersession resolution and returns replaced records as if current.",
-  input: import_zod14.z.object({
+  input: import_zod15.z.object({
     bundlePath,
     conceptId,
-    hops: import_zod14.z.number().int().positive().optional().describe("How far from the root the walk may reach. Defaults to 2."),
-    maxNodes: import_zod14.z.number().int().positive().optional().describe(
+    hops: import_zod15.z.number().int().positive().optional().describe("How far from the root the walk may reach. Defaults to 2."),
+    maxNodes: import_zod15.z.number().int().positive().optional().describe(
       "How many records the pack may hold, root included. Defaults to 20."
     ),
-    budgetTokens: import_zod14.z.number().int().positive().optional().describe(
+    budgetTokens: import_zod15.z.number().int().positive().optional().describe(
       "Approximate token ceiling over what is actually emitted. Defaults to 25000."
     )
   }),
@@ -1962,22 +2652,22 @@ function warningLabel(warning) {
 }
 
 // src/commands/pin.ts
-var import_zod15 = require("zod");
+var import_zod16 = 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 pin manifest, so `context` surfaces it at every context birth. Three layers, nearest wins: the committed project manifest (.strauss/kb-pins.json, the default), `--local` (.strauss/kb-pins.local.json, personal and gitignored), and `--user` (~/.strauss/kb-pins.json, every workspace). Idempotent \u2014 re-pinning changes nothing unless --mode, --profiles, or --frozen/--unfreeze are given, which update just those fields. `--mode full` preloads the whole base into the block regardless of the full-under threshold; `--mode index` never upgrades. `--profiles` scopes the pin to named context profiles. `--frozen` marks the base concluded: write commands against it refuse and `context` labels it read-only. A path with no records yet succeeds with a warning; bases are routinely pinned before they are populated. Pins are workspace state: the pinned base itself is never touched.",
-  input: import_zod15.z.object({
+  input: import_zod16.z.object({
     bundlePath,
-    mode: import_zod15.z.enum(["full", "index"]).optional().describe(
+    mode: import_zod16.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_zod15.z.array(import_zod15.z.string()).optional().describe("Context profiles this pin surfaces in. Absent: all of them."),
-    layer: import_zod15.z.enum(["project", "local", "user"]).optional().describe(
+    profiles: import_zod16.z.array(import_zod16.z.string()).optional().describe("Context profiles this pin surfaces in. Absent: all of them."),
+    layer: import_zod16.z.enum(["project", "local", "user"]).optional().describe(
       "Which manifest to write: project (committed, default), local (personal, gitignored), user (~/.strauss, every workspace)."
     ),
-    frozen: import_zod15.z.boolean().optional().describe(
+    frozen: import_zod16.z.boolean().optional().describe(
       "true: the base is concluded \u2014 writes against it refuse while pinned. false: lift a freeze."
     )
   }),
@@ -2006,38 +2696,48 @@ var pinCommand = define({
 });
 
 // src/commands/pins.ts
-var import_zod16 = require("zod");
+var import_zod17 = require("zod");
 var pinsCommand = define({
   name: "pins",
   tool: "kb_pins",
   usage: "pins",
   description: "Every pinned base across the manifest layers, each with its layer and whether it currently resolves to readable records. Reads the workspace manifests rather than any one base, like kb_context.",
-  input: import_zod16.z.object({}),
+  input: import_zod17.z.object({}),
   fromArgv: () => ({}),
   run: ({ store }) => listPins(store, process.cwd())
 });
 
 // src/commands/query.ts
-var import_zod17 = require("zod");
+var import_zod18 = require("zod");
 var queryCommand = define({
   name: "query",
   tool: "kb_query",
-  usage: "query <text...>",
-  description: "Search and return each match with its standing. Results are flagged, never filtered: a superseded record comes back alongside whatever replaced it, and a rejected one is marked as something explicitly not adopted. This is the lookup-by-wording rung, and the narrowest of the three: use it when you know roughly what the record says. The decision rule around it \u2014 while the base fits kb_load's token budget, kb_load it whole, because on this package's measurements a reader holding the whole base answered eight of nine questions whose wording appears in no record where embedding search answered four; once kb_load refuses, kb_catalog for one line per record and then kb_pack on the record the work centres on; and kb_query when the question is a point lookup rather than a neighbourhood. A query cannot tell you that nothing was decided \u2014 it returns its nearest hit whatever the distance \u2014 so reach for kb_catalog when the question is what exists. Never read record files directly: this tool (with kb_load, kb_catalog, kb_pack and kb_trace) is the only supported way to read a base; a file read bypasses supersession resolution and returns replaced records as if current.",
-  input: import_zod17.z.object({
+  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_zod18.z.object({
     bundlePath,
-    text: import_zod17.z.string().optional(),
-    type: import_zod17.z.enum(KB_RECORD_TYPES).optional(),
-    includeNonCurrent: import_zod17.z.boolean().optional()
+    text: import_zod18.z.string().optional(),
+    type: import_zod18.z.enum(KB_RECORD_TYPES).optional(),
+    includeNonCurrent: import_zod18.z.boolean().optional(),
+    repoRoot: REPO_ROOT
   }),
-  fromArgv: (argv, path) => ({
-    bundlePath: path,
-    text: argv.slice(1).join(" ").trim(),
-    includeNonCurrent: true
-  }),
-  run: async ({ store }, { bundlePath: path, text, type, includeNonCurrent }) => (await store.query(path, text ?? "", {
+  // `--repo-root` is a flag, so its value must not fall into the search text.
+  fromArgv: (argv, path) => {
+    const repoRoot = argvFlag(argv, "--repo-root");
+    const words = argv.slice(1);
+    const flag = words.indexOf("--repo-root");
+    if (flag !== -1) words.splice(flag, 2);
+    return {
+      bundlePath: path,
+      text: words.join(" ").trim(),
+      includeNonCurrent: true,
+      ...repoRoot !== void 0 ? { repoRoot } : {}
+    };
+  },
+  run: async ({ store }, { bundlePath: path, text, type, includeNonCurrent, repoRoot }) => (await store.query(path, text ?? "", {
     ...type ? { type } : {},
-    includeNonCurrent: includeNonCurrent === true
+    includeNonCurrent: includeNonCurrent === true,
+    ...repoRoot !== void 0 ? { repoRoot } : {}
   })).map((hit) => ({
     conceptId: hit.record.conceptId,
     title: hit.record.frontmatter.title ?? null,
@@ -2050,27 +2750,27 @@ var queryCommand = define({
 });
 
 // src/commands/read-index.ts
-var import_zod18 = require("zod");
+var import_zod19 = require("zod");
 var readIndexCommand = define({
   name: "index",
   tool: "kb_index",
   usage: "index",
   description: "The index, rebuilt if it disagrees with the records. One call gives the whole shape of the base: title, type, status, and description per record. The cheap re-orientation call after compaction or deep in a long session \u2014 a few hundred tokens; call it (or kb_context, when bases are pinned) first, then kb_load or fetch by concept id.",
-  input: import_zod18.z.object({ bundlePath }),
+  input: import_zod19.z.object({ bundlePath }),
   fromArgv: (_argv, path) => ({ bundlePath: path }),
   run: ({ store }, { bundlePath: path }) => store.readIndex(path)
 });
 
 // src/commands/schema.ts
-var import_zod21 = require("zod");
+var import_zod22 = require("zod");
 
 // src/json-schema.ts
-var import_zod20 = require("zod");
+var import_zod21 = require("zod");
 
 // src/kb-log.ts
-var import_zod19 = require("zod");
+var import_zod20 = require("zod");
 var LOG_FILE = "log.jsonl";
-var kbLogEntrySchema = import_zod19.z.object({
+var kbLogEntrySchema = import_zod20.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
@@ -2079,12 +2779,12 @@ var kbLogEntrySchema = import_zod19.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_zod19.z.iso.datetime(),
-  by: import_zod19.z.string().min(1),
-  operation: import_zod19.z.string().min(1),
-  conceptId: import_zod19.z.string().min(1),
+  at: import_zod20.z.iso.datetime(),
+  by: import_zod20.z.string().min(1),
+  operation: import_zod20.z.string().min(1),
+  conceptId: import_zod20.z.string().min(1),
   /** Second concept id, where the operation relates two — supersession. */
-  target: import_zod19.z.string().min(1).optional()
+  target: import_zod20.z.string().min(1).optional()
 }).strict();
 function renderLogEntry(entry) {
   return `${JSON.stringify(kbLogEntrySchema.parse(entry))}
@@ -2122,11 +2822,11 @@ function parseLog(raw) {
 // src/json-schema.ts
 function kbJsonSchemas() {
   return {
-    recordFrontmatter: import_zod20.z.toJSONSchema(kbRecordFrontmatterSchema, {
+    recordFrontmatter: import_zod21.z.toJSONSchema(kbRecordFrontmatterSchema, {
       io: "input"
     }),
-    composeInput: import_zod20.z.toJSONSchema(composeInputSchema, { io: "input" }),
-    logEntry: import_zod20.z.toJSONSchema(kbLogEntrySchema, { io: "input" })
+    composeInput: import_zod21.z.toJSONSchema(composeInputSchema, { io: "input" }),
+    logEntry: import_zod21.z.toJSONSchema(kbLogEntrySchema, { io: "input" })
   };
 }
 
@@ -2136,22 +2836,22 @@ var schemaCommand = define({
   tool: "kb_schema",
   usage: "schema",
   description: "JSON Schema for the frontmatter, the write input, and log entries \u2014 generated from the code that enforces them, so it cannot drift from what a write will accept.",
-  input: import_zod21.z.object({}),
+  input: import_zod22.z.object({}),
   fromArgv: () => ({}),
   run: () => Promise.resolve(kbJsonSchemas())
 });
 
 // src/commands/status.ts
-var import_zod22 = require("zod");
+var import_zod23 = require("zod");
 var statusCommand = define({
   name: "status",
   tool: "kb_status",
   usage: "status <concept-id> <status>",
   description: "Move a record's status, leaving everything else alone. Uses a compare-and-swap, so a concurrent change fails loudly rather than being overwritten.",
-  input: import_zod22.z.object({
+  input: import_zod23.z.object({
     bundlePath,
     conceptId,
-    status: import_zod22.z.enum(KB_RECORD_STATUSES)
+    status: import_zod23.z.enum(KB_RECORD_STATUSES)
   }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
@@ -2166,13 +2866,13 @@ var statusCommand = define({
 });
 
 // src/commands/supersede.ts
-var import_zod23 = require("zod");
+var import_zod24 = require("zod");
 var supersedeCommand = define({
   name: "supersede",
   tool: "kb_supersede",
   usage: "supersede <concept-id> <replacement-id>",
   description: "Mark a record superseded by another, linking both directions. Use this rather than editing a record whose meaning changed \u2014 a record that quietly becomes something else invalidates every reference to it, and the earlier understanding is what a later trace needs.",
-  input: import_zod23.z.object({ bundlePath, conceptId, replacementId: conceptId }),
+  input: import_zod24.z.object({ bundlePath, conceptId, replacementId: conceptId }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
     conceptId: argv[1],
@@ -2186,16 +2886,16 @@ var supersedeCommand = define({
 });
 
 // src/commands/sync-instructions.ts
-var import_zod24 = require("zod");
+var import_zod25 = require("zod");
 var syncInstructionsCommand = define({
   name: "sync-instructions",
   usage: "sync-instructions <file> [--profile NAME] [--budget N] [--full-under N]",
   description: "Idempotently plant the `context` block between sentinel comments in an instruction file (AGENTS.md, CLAUDE.md), creating the block when absent and leaving everything outside the sentinels alone. CLI-only: this is file plumbing for runtimes whose instruction files are re-read where their conversations are not, not an agent capability \u2014 the capability is kb_context.",
-  input: import_zod24.z.object({
-    file: import_zod24.z.string().min(1).describe("The instruction file to edit in place."),
-    budgetTokens: import_zod24.z.number().int().positive().optional(),
-    fullUnderTokens: import_zod24.z.number().int().positive().optional(),
-    profile: import_zod24.z.string().optional()
+  input: import_zod25.z.object({
+    file: import_zod25.z.string().min(1).describe("The instruction file to edit in place."),
+    budgetTokens: import_zod25.z.number().int().positive().optional(),
+    fullUnderTokens: import_zod25.z.number().int().positive().optional(),
+    profile: import_zod25.z.string().optional()
   }),
   fromArgv: (argv) => {
     const budget = argvFlag(argv, "--budget");
@@ -2221,7 +2921,7 @@ var syncInstructionsCommand = define({
 });
 
 // src/commands/trace.ts
-var import_zod25 = require("zod");
+var import_zod26 = require("zod");
 
 // src/trace.ts
 var TRACE_EDGES = ["supersession", "anchor", "source"];
@@ -2267,11 +2967,11 @@ var traceCommand = define({
   tool: "kb_trace",
   usage: "trace <concept-id> [edges...]",
   description: 'How a position was arrived at, as a timeline ordered by when each record was written. Deliberately includes rejected, draft, and superseded records \u2014 in a history those are the content, not noise. Follows supersession, shared code anchors, and shared sources. Use when the question is "why is this the way it is" rather than "what do we hold now". This tool (with kb_load and kb_query) is the only supported way to read a base; a raw file read bypasses supersession resolution and returns replaced records as if current.',
-  input: import_zod25.z.object({
+  input: import_zod26.z.object({
     bundlePath,
     conceptId,
-    edges: import_zod25.z.array(import_zod25.z.enum(TRACE_EDGES)).optional(),
-    depth: import_zod25.z.number().int().positive().optional()
+    edges: import_zod26.z.array(import_zod26.z.enum(TRACE_EDGES)).optional(),
+    depth: import_zod26.z.number().int().positive().optional()
   }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
@@ -2293,53 +2993,53 @@ var traceCommand = define({
 });
 
 // src/commands/types.ts
-var import_zod26 = require("zod");
+var import_zod27 = 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_zod26.z.object({}),
+  input: import_zod27.z.object({}),
   fromArgv: () => ({}),
   run: () => Promise.resolve(RECORD_TYPES)
 });
 
 // src/commands/unpin.ts
-var import_zod27 = require("zod");
+var import_zod28 = require("zod");
 var unpinCommand = define({
   name: "unpin",
   tool: "kb_unpin",
   usage: "unpin [bundle-path]",
   description: "Remove a base from every pin manifest layer that holds it \u2014 project, local, and user \u2014 because unpinned means gone, not still injected from another file. Reports which layers were touched.",
-  input: import_zod27.z.object({ bundlePath }),
+  input: import_zod28.z.object({ bundlePath }),
   fromArgv: (argv, path) => ({ bundlePath: argv[1] ?? path }),
   run: (_ctx, { bundlePath: path }) => unpinBase(process.cwd(), path)
 });
 
 // src/commands/validate.ts
-var import_zod28 = require("zod");
+var import_zod29 = 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, and assumptions that cite sources. Per-record shape is enforced on every read, so a problem here means someone edited a file by hand.",
-  input: import_zod28.z.object({ bundlePath }),
+  input: import_zod29.z.object({ bundlePath }),
   fromArgv: (_argv, path) => ({ bundlePath: path }),
   run: async ({ store }, { bundlePath: path }) => validateBundle(await store.list(path)),
   failsWhen: (result) => Array.isArray(result) && result.length > 0
 });
 
 // src/commands/verify.ts
-var import_zod29 = require("zod");
+var import_zod30 = require("zod");
 var verifyCommand = define({
   name: "verify",
   tool: "kb_verify",
   usage: "verify <concept-id> --note <text>",
   description: "Append one verified[] event \u2014 who checked the record, when, and what the check found. Appends only; prior events are never rewritten. A record's own generator is refused unless the actor is human: re-reading your own output is not an independent check.",
-  input: import_zod29.z.object({
+  input: import_zod30.z.object({
     bundlePath,
     conceptId,
-    note: import_zod29.z.string().refine((s) => s.trim().length > 0, {
+    note: import_zod30.z.string().refine((s) => s.trim().length > 0, {
       message: "note must say what the check found"
     })
   }),
@@ -2359,7 +3059,7 @@ var verifyCommand = define({
 });
 
 // src/commands/write.ts
-var import_zod30 = require("zod");
+var import_zod31 = require("zod");
 var writeCommand = define({
   name: "write",
   tool: "kb_write",
@@ -2373,9 +3073,9 @@ var writeCommand = define({
     "- Prefer a new record over overloading an existing one, and keep each short. A record nobody finishes reading is not durable memory.",
     "- Records are never deleted; supersede instead, so the earlier reasoning stays inspectable."
   ].join("\n"),
-  input: import_zod30.z.object({
+  input: import_zod31.z.object({
     bundlePath,
-    type: import_zod30.z.enum(KB_RECORD_TYPES),
+    type: import_zod31.z.enum(KB_RECORD_TYPES),
     input: composeInputSchema
   }),
   fromArgv: async (argv, path, stdin) => ({
@@ -2399,7 +3099,7 @@ var writeCommand = define({
 });
 
 // src/commands/write-decision.ts
-var import_zod31 = require("zod");
+var import_zod32 = require("zod");
 var writeDecisionCommand = define({
   name: "write-decision",
   tool: "kb_write_decision",
@@ -2412,7 +3112,7 @@ var writeDecisionCommand = define({
     "- `alternative` is what you turned down and why, not a list of everything considered.",
     "- A reference to material you read goes in `sources`; a reference to code goes in `anchors`; a reference to another record goes in `relatedConceptIds`."
   ].join("\n"),
-  input: import_zod31.z.object({ bundlePath, input: decisionInputSchema }),
+  input: import_zod32.z.object({ bundlePath, input: decisionInputSchema }),
   fromArgv: async (_argv, path, stdin) => ({
     bundlePath: path,
     input: JSON.parse(await stdin())
@@ -2441,6 +3141,7 @@ var KB_COMMANDS = [
   supersedeCommand,
   answerCommand,
   verifyCommand,
+  anchorResolveCommand,
   loadCommand,
   catalogCommand,
   packCommand,
@@ -2464,9 +3165,9 @@ var KB_COMMANDS_BY_NAME = new Map(
 );
 
 // src/kb-store.ts
-var import_node_crypto = require("crypto");
-var import_promises4 = require("fs/promises");
-var import_node_path6 = require("path");
+var import_node_crypto2 = require("crypto");
+var import_promises5 = require("fs/promises");
+var import_node_path7 = require("path");
 
 // src/markdown.ts
 var import_gray_matter = __toESM(require("gray-matter"), 1);
@@ -2494,8 +3195,8 @@ function parseMarkdownWithFrontmatter(text, schema) {
 }
 
 // src/search-index.ts
-var import_promises3 = require("fs/promises");
-var import_node_path5 = require("path");
+var import_promises4 = require("fs/promises");
+var import_node_path6 = require("path");
 var SEARCH_INDEX_FILE = ".index.sqlite";
 var COLLECTION = "kb";
 async function searchBase(bundlePath2, query, options = {}) {
@@ -2504,7 +3205,7 @@ async function searchBase(bundlePath2, query, options = {}) {
   let store = null;
   try {
     store = await qmd.createStore({
-      dbPath: (0, import_node_path5.join)(bundlePath2, SEARCH_INDEX_FILE),
+      dbPath: (0, import_node_path6.join)(bundlePath2, SEARCH_INDEX_FILE),
       config: {
         collections: {
           [COLLECTION]: {
@@ -2539,16 +3240,19 @@ async function searchBase(bundlePath2, query, options = {}) {
   }
 }
 async function isStale(bundlePath2) {
-  const indexAt = await (0, import_promises3.stat)((0, import_node_path5.join)(bundlePath2, SEARCH_INDEX_FILE)).then((s) => s.mtimeMs).catch(() => 0);
+  const indexAt = await (0, import_promises4.stat)((0, import_node_path6.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(() => []);
-  for (const name of names) {
-    if (!name.endsWith(".md") || name === INDEX_FILE) continue;
-    const at = await (0, import_promises3.stat)((0, import_node_path5.join)(bundlePath2, name)).then((s) => s.mtimeMs).catch(() => 0);
-    if (at > indexAt) return true;
-  }
-  return false;
+  const names = (await readdir2(bundlePath2).catch(() => [])).filter(
+    (name) => name.endsWith(".md") && name !== INDEX_FILE
+  );
+  let stale = false;
+  await mapLimit(names, DEFAULT_IO_CONCURRENCY, async (name) => {
+    if (stale) return;
+    const at = await (0, import_promises4.stat)((0, import_node_path6.join)(bundlePath2, name)).then((s) => s.mtimeMs).catch(() => 0);
+    if (at > indexAt) stale = true;
+  });
+  return stale;
 }
 function resolveHits(hits, records) {
   const byName = /* @__PURE__ */ new Map();
@@ -2688,7 +3392,7 @@ function appendUnionMergeLine(contents) {
 }
 
 // src/kb-store.ts
-var KB_DIR = (0, import_node_path6.join)(".strauss", "kb");
+var KB_DIR = (0, import_node_path7.join)(".strauss", "kb");
 var STORE_OWNED = /* @__PURE__ */ new Set([INDEX_FILE, LOG_FILE, SEARCH_INDEX_FILE]);
 var DEFAULT_LOAD_BUDGET = 25e3;
 var KbStore = class {
@@ -2719,7 +3423,7 @@ var KbStore = class {
     const conceptId2 = `${input.type}.${input.slug}`;
     const root = this.root(bundlePath2);
     const target = this.recordPath(bundlePath2, conceptId2);
-    await (0, import_promises4.mkdir)(root, { recursive: true });
+    await (0, import_promises5.mkdir)(root, { recursive: true });
     await this.publish(
       target,
       stringifyMarkdownWithFrontmatter(input.body, frontmatter),
@@ -2758,7 +3462,7 @@ var KbStore = class {
     const target = this.recordPath(bundlePath2, conceptId2);
     let raw;
     try {
-      raw = await (0, import_promises4.readFile)(target, "utf8");
+      raw = await (0, import_promises5.readFile)(target, "utf8");
     } catch {
       return null;
     }
@@ -2775,15 +3479,15 @@ var KbStore = class {
     const root = this.root(bundlePath2);
     let names;
     try {
-      names = await (0, import_promises4.readdir)(root);
+      names = await (0, import_promises5.readdir)(root);
     } catch {
       return [];
     }
     const wanted = names.sort().filter((name) => name.endsWith(".md") && !STORE_OWNED.has(name)).map((name) => ({ name, conceptId: name.slice(0, -".md".length) })).filter(({ conceptId: conceptId2 }) => !type || conceptId2.startsWith(`${type}.`));
-    const records = await Promise.all(
-      wanted.map(
-        async ({ name, conceptId: conceptId2 }) => this.parse(conceptId2, await (0, import_promises4.readFile)((0, import_node_path6.join)(root, name), "utf8"))
-      )
+    const records = await mapLimit(
+      wanted,
+      DEFAULT_IO_CONCURRENCY,
+      async ({ name, conceptId: conceptId2 }) => this.parse(conceptId2, await (0, import_promises5.readFile)((0, import_node_path7.join)(root, name), "utf8"))
     );
     return records.filter((record) => record !== null);
   }
@@ -2805,6 +3509,21 @@ var KbStore = class {
       { operation: `status:${status}`, by: actor }
     );
   }
+  /**
+   * Replaces a record's anchors wholesale, preserving everything else.
+   *
+   * Wholesale rather than merged: the caller just resolved the anchors it is
+   * writing, so it holds the complete current set, and a merge would keep
+   * stale entries the resolution pass deliberately dropped.
+   */
+  async updateAnchors(bundlePath2, conceptId2, anchors, actor = "unknown") {
+    return this.mutate(
+      bundlePath2,
+      conceptId2,
+      (frontmatter) => ({ ...frontmatter, strauss_anchors: anchors }),
+      { operation: "anchor-resolve", by: actor }
+    );
+  }
   /**
    * Appends one `verified[]` event: who checked the record, when, and what the
    * check found. Append-only — prior events are history, and are spread into
@@ -2903,9 +3622,12 @@ ${answer}
     const bundle = await this.list(bundlePath2);
     const needle = text.trim();
     const hits = needle ? await this.rank(bundlePath2, needle, bundle) : bundle;
+    const narrowed = options.type ? hits.filter((r) => r.frontmatter.type === options.type) : hits;
     const adjudicated = adjudicate(
-      options.type ? hits.filter((r) => r.frontmatter.type === options.type) : hits,
-      bundle
+      narrowed,
+      bundle,
+      /* @__PURE__ */ new Date(),
+      await this.detectDrift(narrowed, options.repoRoot)
     );
     if (options.includeNonCurrent) return adjudicated;
     const present = new Set(adjudicated.map((hit) => hit.record.conceptId));
@@ -2924,6 +3646,50 @@ ${answer}
     const lowered = needle.toLowerCase();
     return bundle.filter((record) => matches(record, lowered));
   }
+  /**
+   * Anchor drift over the records about to be handed back. Like the search
+   * index, this is an enrichment: a filesystem failure degrades to "no drift
+   * reported" rather than failing the read. Anchors without a stored hash are
+   * skipped inside `detectAnchorDrift`, so a base nobody has stamped pays no
+   * fs cost here. `repoRoot` defaults to the working directory — the CLI runs
+   * at the repo root, and the MCP server's cwd is the workspace.
+   *
+   * Public because `doctor` needs the same map with the same degradation: a
+   * sweep that failed to read the tree should report no drift, not fail.
+   *
+   * When no root was given and not one anchored file was found, the finding is
+   * discarded. A base read from somewhere other than the tree it describes
+   * misses every file at once, and that shape is far likelier to be a wrong
+   * default root than a repository where every anchored file was deleted on
+   * the same day. Reporting it would put a drift warning on every record in
+   * the base, which teaches a reader to ignore the warning — the one outcome
+   * worse than not having it. One file found anywhere makes the root
+   * plausible, and the misses become findings again; an explicit `repoRoot` is
+   * taken at its word either way.
+   */
+  async detectDrift(records, repoRoot) {
+    try {
+      const drift = await detectAnchorDrift(records, {
+        repoRoot: repoRoot ?? process.cwd()
+      });
+      if (repoRoot === void 0 && looksLikeWrongRepoRoot(drift)) {
+        this.logger.warn?.({
+          operation: "kb.anchor-drift",
+          outcome: "skipped",
+          reason: "no anchored file found under the default repo root"
+        });
+        return void 0;
+      }
+      return drift;
+    } catch (error) {
+      this.logger.warn?.({
+        operation: "kb.anchor-drift",
+        outcome: "skipped",
+        error: error instanceof Error ? error.message : "unknown"
+      });
+      return void 0;
+    }
+  }
   /**
    * The whole base, adjudicated, when it is small enough to hand over.
    *
@@ -2958,10 +3724,16 @@ ${answer}
     const budgetTokens = options.budgetTokens ?? DEFAULT_LOAD_BUDGET;
     const bundle = await this.list(bundlePath2);
     const wanted = options.type ? bundle.filter((record) => record.frontmatter.type === options.type) : bundle;
-    const adjudicated = adjudicate(wanted, bundle);
+    const adjudicated = adjudicate(
+      wanted,
+      bundle,
+      /* @__PURE__ */ new Date(),
+      await this.detectDrift(wanted, options.repoRoot)
+    );
     const records = adjudicated.filter((hit) => hit.standing !== "superseded");
     const superseded = adjudicated.filter((hit) => hit.standing === "superseded").map(stub);
     const approxTokens2 = records.reduce((total, hit) => total + estimateTokens(hit.record), 0) + superseded.reduce((total, entry) => total + estimateStubTokens(entry), 0);
+    const bundleDigestValue = bundleDigest(records, superseded);
     if (!options.all && approxTokens2 > budgetTokens) {
       return {
         loaded: false,
@@ -2972,7 +3744,8 @@ ${answer}
           approxTokens: approxTokens2,
           budgetTokens,
           type: options.type
-        })
+        }),
+        digest: bundleDigestValue
       };
     }
     return {
@@ -2981,7 +3754,8 @@ ${answer}
       tokensLoaded: approxTokens2,
       budgetTokens: options.all ? null : budgetTokens,
       records,
-      superseded
+      superseded,
+      digest: bundleDigestValue
     };
   }
   /** How a position was arrived at, as a timeline. See `trace.ts`. */
@@ -3006,11 +3780,11 @@ ${answer}
   async readIndex(bundlePath2) {
     const root = this.root(bundlePath2);
     const expected = renderIndex(await this.list(bundlePath2));
-    const stored = await (0, import_promises4.readFile)((0, import_node_path6.join)(root, INDEX_FILE), "utf8").catch(
+    const stored = await (0, import_promises5.readFile)((0, import_node_path7.join)(root, INDEX_FILE), "utf8").catch(
       () => null
     );
     if (indexIsStale(stored, expected)) {
-      await this.publish((0, import_node_path6.join)(root, INDEX_FILE), expected, true, INDEX_FILE);
+      await this.publish((0, import_node_path7.join)(root, INDEX_FILE), expected, true, INDEX_FILE);
       this.logger.info?.({
         operation: "kb.index.repair",
         bundlePath: root,
@@ -3027,8 +3801,8 @@ ${answer}
    * knows which agent touched what. So a bad line is surfaced and left alone.
    */
   async readLog(bundlePath2) {
-    const raw = await (0, import_promises4.readFile)(
-      (0, import_node_path6.join)(this.root(bundlePath2), LOG_FILE),
+    const raw = await (0, import_promises5.readFile)(
+      (0, import_node_path7.join)(this.root(bundlePath2), LOG_FILE),
       "utf8"
     ).catch(() => "");
     const result = parseLog(raw);
@@ -3079,14 +3853,14 @@ ${answer}
   }
   async mutate(bundlePath2, conceptId2, change, entry, changeBody = (body) => body) {
     const target = this.recordPath(bundlePath2, conceptId2);
-    const before = await (0, import_promises4.readFile)(target, "utf8").catch(() => null);
+    const before = await (0, import_promises5.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_promises4.readFile)(target, "utf8").catch(() => null);
+    const witness = await (0, import_promises5.readFile)(target, "utf8").catch(() => null);
     if (witness === null || digest(witness) !== digest(before)) {
       throw new KbWriteConflictError(conceptId2);
     }
@@ -3112,20 +3886,20 @@ ${answer}
    */
   async publish(target, contents, overwrite, conceptId2) {
     const staging = `${target}.${process.pid}.tmp`;
-    await (0, import_promises4.writeFile)(staging, contents, "utf8");
+    await (0, import_promises5.writeFile)(staging, contents, "utf8");
     try {
       if (overwrite) {
-        await (0, import_promises4.rename)(staging, target);
+        await (0, import_promises5.rename)(staging, target);
         return;
       }
-      await (0, import_promises4.link)(staging, target);
+      await (0, import_promises5.link)(staging, target);
     } catch (error) {
       if (error.code === "EEXIST") {
         throw new KbRecordAlreadyExistsError(conceptId2);
       }
       throw error;
     } finally {
-      await (0, import_promises4.unlink)(staging).catch(() => void 0);
+      await (0, import_promises5.unlink)(staging).catch(() => void 0);
     }
   }
   /**
@@ -3169,20 +3943,30 @@ ${answer}
    * file must not fail the mutation it guards.
    */
   async ensureGitattributes(root) {
-    const target = (0, import_node_path6.join)(root, GITATTRIBUTES_FILE);
+    const target = (0, import_node_path7.join)(root, GITATTRIBUTES_FILE);
     try {
       let existing;
       try {
-        existing = await (0, import_promises4.readFile)(target, "utf8");
+        existing = await (0, import_promises5.readFile)(target, "utf8");
       } catch (error) {
         if (error.code !== "ENOENT") throw error;
         existing = null;
       }
       if (existing === null) {
-        await (0, import_promises4.writeFile)(target, appendUnionMergeLine(""), {
-          encoding: "utf8",
-          flag: "wx"
-        });
+        try {
+          await (0, import_promises5.writeFile)(target, appendUnionMergeLine(""), {
+            encoding: "utf8",
+            flag: "wx"
+          });
+        } catch (error) {
+          if (error.code !== "EEXIST") throw error;
+          this.logger.info?.({
+            operation: "kb.gitattributes.ensure",
+            bundlePath: root,
+            outcome: "exists"
+          });
+          return;
+        }
         this.logger.info?.({
           operation: "kb.gitattributes.ensure",
           bundlePath: root,
@@ -3191,7 +3975,7 @@ ${answer}
         return;
       }
       if (!hasMergeDeclaration(existing)) {
-        await (0, import_promises4.appendFile)(target, appendUnionMergeLine(existing), "utf8");
+        await (0, import_promises5.appendFile)(target, appendUnionMergeLine(existing), "utf8");
         this.logger.info?.({
           operation: "kb.gitattributes.ensure",
           bundlePath: root,
@@ -3210,7 +3994,7 @@ ${answer}
   async record(root, entry) {
     await this.ensureGitattributes(root);
     const line = renderLogEntry({ at: (/* @__PURE__ */ new Date()).toISOString(), ...entry });
-    await (0, import_promises4.appendFile)((0, import_node_path6.join)(root, LOG_FILE), line, "utf8").catch((error) => {
+    await (0, import_promises5.appendFile)((0, import_node_path7.join)(root, LOG_FILE), line, "utf8").catch((error) => {
       this.logger.warn?.({
         operation: "kb.log.append",
         outcome: "failed",
@@ -3236,18 +4020,18 @@ ${answer}
     };
   }
   root(bundlePath2) {
-    return (0, import_node_path6.resolve)(bundlePath2);
+    return (0, import_node_path7.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_path6.sep) || conceptId2.includes("/")) {
+    if (conceptId2.includes(import_node_path7.sep) || conceptId2.includes("/")) {
       throw new KbInvalidConceptIdError(
         "concept id must not contain a path separator",
         { conceptId: conceptId2 }
       );
     }
-    return (0, import_node_path6.join)(this.root(bundlePath2), `${conceptId2}.md`);
+    return (0, import_node_path7.join)(this.root(bundlePath2), `${conceptId2}.md`);
   }
 };
 function estimateTokens(record) {
@@ -3286,11 +4070,27 @@ function normalizeActor(id) {
   return id.slice(0, colon + 1).toLowerCase() + id.slice(colon + 1);
 }
 function digest(contents) {
-  return (0, import_node_crypto.createHash)("sha256").update(contents).digest("hex");
+  return (0, import_node_crypto2.createHash)("sha256").update(contents).digest("hex");
+}
+function bundleDigest(records, superseded) {
+  const entries = [
+    ...records.map(
+      (hit) => `${hit.record.conceptId}:current:${digest(
+        stringifyMarkdownWithFrontmatter(
+          hit.record.body,
+          hit.record.frontmatter
+        )
+      )}`
+    ),
+    ...superseded.map(
+      (entry) => `${entry.conceptId}:superseded:${digest(JSON.stringify(entry))}`
+    )
+  ].sort();
+  return digest(entries.join("\n"));
 }
 
 // src/version.ts
-var VERSION = true ? "0.1.10" : "0.0.0-dev";
+var VERSION = true ? "0.1.12" : "0.0.0-dev";
 
 // src/cli.ts
 async function runKbCli(argv) {
@@ -3349,18 +4149,18 @@ function takeLiteral(argv) {
 function takeBundle(argv) {
   const at = argv.indexOf("--bundle");
   if (at === -1) {
-    return { bundle: (0, import_node_path7.join)(process.cwd(), KB_DIR), rest: argv };
+    return { bundle: (0, import_node_path8.join)(process.cwd(), KB_DIR), rest: argv };
   }
   const bundle = argv[at + 1];
   if (!bundle) die("--bundle requires a path");
   return { bundle, rest: [...argv.slice(0, at), ...argv.slice(at + 2)] };
 }
 function readStdin() {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     let text = "";
     process.stdin.setEncoding("utf8");
     process.stdin.on("data", (chunk) => text += chunk);
-    process.stdin.on("end", () => resolve5(text));
+    process.stdin.on("end", () => resolve6(text));
     process.stdin.on("error", reject);
   });
 }