@saasontools/strauss-kb 0.1.19 → 0.1.20

package/dist/mcp-main.cjs

@@ -8,9 +8,9 @@ var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    for (let key2 of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key2) && key2 !== except)
+        __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable });
   }
   return to;
 };
@@ -55,9 +55,24 @@ var kbVerifiedEventSchema = kbActorStampSchema.extend({
     message: "note must say what the check found"
   })
 });
+var kbAnchorSpanSchema = import_zod.z.object({
+  start: import_zod.z.number().int().positive(),
+  end: import_zod.z.number().int().positive()
+}).strict();
 var kbAnchorSchema = import_zod.z.object({
   file: import_zod.z.string().min(1),
   symbol: import_zod.z.string().min(1).optional(),
+  /**
+   * The lines the concept names, when no symbol covers them — deleted code,
+   * YAML, SQL, Markdown. Alternative to `symbol`, never a refinement of it.
+   */
+  span: kbAnchorSpanSchema.optional(),
+  /**
+   * Which side of the change the anchor describes. `old` is code as it was
+   * committed at `ref`, which is the only way to anchor something deleted;
+   * absent means the working tree.
+   */
+  side: import_zod.z.enum(["old", "new"]).optional(),
   /**
    * Which repository the file lives in — a remote URL
    * (`https://github.com/org/name`) or a short name. Absent means the base's
@@ -96,8 +111,38 @@ var kbAnchorSchema = import_zod.z.object({
    * before resolvers were named, which is read as `regex` — the only one
    * there was. A hash from a different resolver is drift, not a match.
    */
-  resolver: import_zod.z.enum(["tree-sitter", "regex"]).optional()
+  resolver: import_zod.z.enum(["tree-sitter", "regex", "span"]).optional()
 }).strict();
+var kbAnchorWriteSchema = kbAnchorSchema.superRefine((anchor, ctx) => {
+  if (anchor.span && anchor.symbol) {
+    ctx.addIssue({
+      code: import_zod.z.ZodIssueCode.custom,
+      path: ["span"],
+      message: "an anchor names a symbol or a span, not both"
+    });
+  }
+  if (anchor.span && anchor.span.end < anchor.span.start) {
+    ctx.addIssue({
+      code: import_zod.z.ZodIssueCode.custom,
+      path: ["span", "end"],
+      message: "span end must not precede start"
+    });
+  }
+  if (anchor.span && anchor.hash_kind === "ast") {
+    ctx.addIssue({
+      code: import_zod.z.ZodIssueCode.custom,
+      path: ["hash_kind"],
+      message: "a span is hashed raw, never ast"
+    });
+  }
+  if (anchor.side === "old" && !anchor.ref) {
+    ctx.addIssue({
+      code: import_zod.z.ZodIssueCode.custom,
+      path: ["ref"],
+      message: 'side: "old" needs a ref \u2014 committed code has no other address'
+    });
+  }
+});
 var kbLinkSchema = import_zod.z.object({
   target: import_zod.z.string().min(1),
   rel: import_zod.z.string().min(1)
@@ -313,7 +358,7 @@ var composeInputSchema = import_zod2.z.object({
   why: import_zod2.z.string().min(1),
   /** Keyed by section heading from the type's spec. Unknown keys rejected. */
   sections: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.string().min(1)).optional(),
-  anchors: import_zod2.z.array(kbAnchorSchema).optional(),
+  anchors: import_zod2.z.array(kbAnchorWriteSchema).optional(),
   sources: import_zod2.z.array(kbSourceSchema).optional(),
   /** No source exists, as a claim rather than a sentinel in `sources`. */
   assumption: import_zod2.z.boolean().optional(),
@@ -458,6 +503,14 @@ function composeNoDecisionRecord(reason, writtenBy, writtenAt) {
     writtenAt
   );
 }
+function isNoDecisionRecord(record) {
+  return record.conceptId === `${DECISION_TYPE}.${NO_DECISION_SLUG}`;
+}
+function selectDecisions(records) {
+  return records.filter(
+    (record) => record.conceptId.startsWith(`${DECISION_TYPE}.`) && !isNoDecisionRecord(record)
+  );
+}
 
 // src/commands/anchor-resolve.ts
 var import_zod7 = require("zod");
@@ -491,14 +544,258 @@ async function mapLimit(items, limit, fn) {
   return out;
 }
 
+// src/drift/git.ts
+var import_node_child_process2 = require("child_process");
+var import_node_util2 = require("util");
+
+// src/remote-repo/git.ts
+var import_node_child_process = require("child_process");
+var import_node_util = require("util");
+
+// src/anchor-resolver/model.ts
+var MAX_ANCHOR_FILE_BYTES = 1048576;
+
+// src/remote-repo/git.ts
+var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
+function childEnv() {
+  const env = { ...process.env, GIT_TERMINAL_PROMPT: "0" };
+  for (const name of ["GIT_DIR", "GIT_WORK_TREE", "GIT_INDEX_FILE"]) {
+    delete env[name];
+  }
+  return env;
+}
+async function git(args, options = {}) {
+  try {
+    const { stdout, stderr } = await execFileAsync("git", args, {
+      ...options.cwd ? { cwd: options.cwd } : {},
+      timeout: options.timeoutMs ?? 3e4,
+      maxBuffer: options.maxBytes ?? MAX_ANCHOR_FILE_BYTES,
+      encoding: "utf8",
+      windowsHide: true,
+      env: childEnv()
+    });
+    return { ok: true, stdout, stderr, overflowed: false };
+  } catch (error) {
+    const failure = error;
+    return {
+      ok: false,
+      stdout: failure.stdout ?? "",
+      stderr: failure.stderr ?? "",
+      overflowed: failure.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER"
+    };
+  }
+}
+function transportReason(stderr) {
+  const text = stderr.toLowerCase();
+  if (text.includes("authentication failed") || text.includes("permission denied") || text.includes("could not read username") || text.includes("403 forbidden") || text.includes("access denied")) {
+    return "repo-unauthorized";
+  }
+  if (text.includes("couldn't find remote ref") || text.includes("unadvertised object") || text.includes("not our ref")) {
+    return "ref-not-found";
+  }
+  return "remote-unreachable";
+}
+
+// src/remote-repo/validate.ts
+var MAX_REF_LENGTH = 200;
+var REF_SHAPE = /^[A-Za-z0-9][A-Za-z0-9._/-]*$/;
+function refShapeIsSafe(ref) {
+  if (!ref || ref.length > MAX_REF_LENGTH) return false;
+  if (ref.includes("..")) return false;
+  return REF_SHAPE.test(ref);
+}
+function localRevShapeIsSafe(rev) {
+  if (!rev || rev.length > MAX_REF_LENGTH) return false;
+  if (rev.includes("..")) return false;
+  return /^[A-Za-z0-9][A-Za-z0-9._/^~-]*$/.test(rev);
+}
+async function refIsWellFormed(ref) {
+  if (!refShapeIsSafe(ref)) return false;
+  const checked = await git(["check-ref-format", "--allow-onelevel", ref]);
+  return checked.ok;
+}
+function filePathIsSafe(file) {
+  const path = file.replace(/^\.\//, "");
+  if (!path || path.startsWith("-") || path.includes("\0")) return false;
+  return !path.split("/").includes("..");
+}
+var DEFAULT_PROTOCOLS = ["https", "ssh", "git"];
+function allowedProtocols() {
+  const raw = process.env["STRAUSS_KB_REPO_PROTOCOLS"];
+  if (raw === void 0) return [...DEFAULT_PROTOCOLS];
+  const listed = raw.split(",").map((entry) => entry.trim().toLowerCase()).filter(Boolean);
+  return listed.length ? listed : [...DEFAULT_PROTOCOLS];
+}
+function isShortRepoName(repo) {
+  return /^[A-Za-z0-9._-]+(?:\/[A-Za-z0-9._-]+)*$/.test(repo.trim());
+}
+var SCP_LIKE = /^[\w.-]+@[\w.-]+:(?!\/)\S+$/;
+var URL_SCHEME = /^([A-Za-z0-9+.-]+):\/\//;
+var CONTROL_CHARS = /[\u0000-\u001f\u007f]/;
+function repoUrlIsSafe(repo) {
+  const url = repo.trim();
+  if (!url || url.startsWith("-") || CONTROL_CHARS.test(url)) return false;
+  const allowed = allowedProtocols();
+  if (SCP_LIKE.test(url)) return allowed.includes("ssh");
+  const scheme = URL_SCHEME.exec(url);
+  if (!scheme?.[1]) return false;
+  if (!allowed.includes(scheme[1].toLowerCase())) return false;
+  const authority = url.slice(scheme[0].length).split("/")[0] ?? "";
+  const at2 = authority.lastIndexOf("@");
+  return at2 < 0 || !authority.slice(0, at2).includes(":");
+}
+function protocolArgs() {
+  const allowed = allowedProtocols();
+  return [
+    "-c",
+    "protocol.ext.allow=never",
+    "-c",
+    `protocol.file.allow=${allowed.includes("file") ? "user" : "never"}`
+  ];
+}
+
+// src/drift/git.ts
+var execFileAsync2 = (0, import_node_util2.promisify)(import_node_child_process2.execFile);
+var MAX_GIT_OUTPUT_BYTES = 1048576;
+var MAX_RANGE_DIFF_BYTES = 8 * 1048576;
+var GIT_TIMEOUT_MS = 5e3;
+var RANGE_DIFF_TIMEOUT_MS = 2e4;
+async function git2(cwd, args, limits = {}) {
+  const env = { ...process.env };
+  delete env["GIT_DIR"];
+  delete env["GIT_WORK_TREE"];
+  delete env["GIT_INDEX_FILE"];
+  try {
+    const { stdout } = await execFileAsync2("git", ["-C", cwd, ...args], {
+      timeout: limits.timeoutMs ?? GIT_TIMEOUT_MS,
+      maxBuffer: limits.maxBytes ?? MAX_GIT_OUTPUT_BYTES,
+      env
+    });
+    return { ok: true, stdout };
+  } catch (error) {
+    return { ok: false, reason: failureOf(error) };
+  }
+}
+function failureOf(error) {
+  const { code, killed } = error;
+  if (code === "ENOENT") return "git-missing";
+  if (code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER") return "too-large";
+  if (killed === true) return "timeout";
+  return "failed";
+}
+async function readFileAtRef(repoRoot, anchor) {
+  if (!filePathIsSafe(anchor.file))
+    return { ok: false, reason: "outside-repo" };
+  if (!anchor.ref || !refShapeIsSafe(anchor.ref)) {
+    return { ok: false, reason: "ref-unreadable" };
+  }
+  const blob = await catBlob(repoRoot, anchor.ref, anchor.file);
+  if (blob !== null) return { ok: true, source: blob };
+  return {
+    ok: false,
+    reason: await hasCommit(repoRoot, anchor.ref) ? "ref-unreadable" : "ref-unavailable"
+  };
+}
+async function hasCommit(repoRoot, ref) {
+  const found = await git2(repoRoot, [
+    "cat-file",
+    "-e",
+    "--end-of-options",
+    `${ref}^{commit}`
+  ]);
+  return found.ok;
+}
+async function listRepoFiles(repoRoot) {
+  const result = await git2(repoRoot, ["ls-files", "-z", "--cached"]);
+  if (!result.ok) return [];
+  return result.stdout.split("\0").filter(Boolean);
+}
+var DIFF_RANGE = /^(.+?)(\.{2,3})(.+)$/;
+async function readRangeDiff(repoRoot, range, maxBytes = MAX_RANGE_DIFF_BYTES) {
+  const parts = DIFF_RANGE.exec(range);
+  if (!parts) return { ok: false, reason: "bad-range" };
+  const [, base2 = "", dots = "", head = ""] = parts;
+  if (!localRevShapeIsSafe(base2) || !localRevShapeIsSafe(head)) {
+    return { ok: false, reason: "bad-range" };
+  }
+  const result = await git2(
+    repoRoot,
+    [
+      "-c",
+      "core.quotePath=false",
+      "diff",
+      "--unified=0",
+      "--no-color",
+      "--no-ext-diff",
+      "--no-textconv",
+      "--find-renames",
+      "--src-prefix=a/",
+      "--dst-prefix=b/",
+      "--end-of-options",
+      `${base2}${dots}${head}`,
+      "--"
+    ],
+    { maxBytes, timeoutMs: RANGE_DIFF_TIMEOUT_MS }
+  );
+  if (result.ok) return { ok: true, text: result.stdout };
+  return {
+    ok: false,
+    reason: result.reason === "failed" ? "bad-range" : result.reason
+  };
+}
+async function readOldSource(repoRoot, anchor) {
+  if (!filePathIsSafe(anchor.file))
+    return { ok: false, reason: "unrecoverable" };
+  if (anchor.ref && refShapeIsSafe(anchor.ref)) {
+    const shown2 = await catBlob(repoRoot, anchor.ref, anchor.file);
+    if (shown2 !== null) {
+      return {
+        ok: true,
+        source: shown2,
+        origin: { kind: "ref", ref: anchor.ref }
+      };
+    }
+  }
+  const at2 = anchor.resolved_at;
+  if (!at2 || Number.isNaN(Date.parse(at2))) {
+    return { ok: false, reason: "unrecoverable" };
+  }
+  const found = await git2(repoRoot, [
+    "log",
+    "-1",
+    "--format=%H",
+    `--before=${at2}`,
+    "--end-of-options",
+    "HEAD",
+    "--",
+    anchor.file
+  ]);
+  const sha = found.ok ? found.stdout.trim() : "";
+  if (!sha || !refShapeIsSafe(sha))
+    return { ok: false, reason: "unrecoverable" };
+  const shown = await catBlob(repoRoot, sha, anchor.file);
+  if (shown === null) return { ok: false, reason: "unrecoverable" };
+  return { ok: true, source: shown, origin: { kind: "history", ref: sha } };
+}
+async function catBlob(repoRoot, ref, file) {
+  const path = file.replace(/^\.\//, "");
+  const result = await git2(repoRoot, [
+    "cat-file",
+    "blob",
+    "--end-of-options",
+    `${ref}:${path}`
+  ]);
+  return result.ok ? result.stdout : null;
+}
+
 // src/remote-repo/cache.ts
 var import_node_os = require("os");
 var import_node_path = require("path");
 
 // src/anchor-resolver/repo-identity.ts
-var import_node_child_process = require("child_process");
-var import_node_util = require("util");
-var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
+var import_node_child_process3 = require("child_process");
+var import_node_util3 = require("util");
+var execFileAsync3 = (0, import_node_util3.promisify)(import_node_child_process3.execFile);
 function normalizeRepoUrl(value) {
   let url = value.trim().replace(/^git\+/, "");
   const scp = /^[\w.-]+@([\w.-]+):(.+)$/.exec(url);
@@ -533,7 +830,7 @@ function repoIdentifies(declared, originUrl) {
 }
 async function repoOriginUrl(repoRoot) {
   try {
-    const { stdout } = await execFileAsync(
+    const { stdout } = await execFileAsync3(
       "git",
       ["-C", repoRoot, "config", "--get", "remote.origin.url"],
       { timeout: 5e3 }
@@ -605,7 +902,9 @@ function revRef(rev) {
 var UNCHECKED_REASONS = [
   "remote-unreachable",
   "repo-unauthorized",
-  "default-branch-unknown"
+  "default-branch-unknown",
+  /** Local, but the same finding: a shallow clone has no rev to read. */
+  "ref-unavailable"
 ];
 function isUncheckedReason(reason) {
   return reason !== void 0 && UNCHECKED_REASONS.includes(reason);
@@ -616,137 +915,34 @@ function wantKey(repo, ref, file) {
 
 // src/remote-repo/read.ts
 var import_promises = require("fs/promises");
-
-// src/remote-repo/git.ts
-var import_node_child_process2 = require("child_process");
-var import_node_util2 = require("util");
-
-// src/anchor-resolver/model.ts
-var MAX_ANCHOR_FILE_BYTES = 1048576;
-
-// src/remote-repo/git.ts
-var execFileAsync2 = (0, import_node_util2.promisify)(import_node_child_process2.execFile);
-function childEnv() {
-  const env = { ...process.env, GIT_TERMINAL_PROMPT: "0" };
-  for (const name of ["GIT_DIR", "GIT_WORK_TREE", "GIT_INDEX_FILE"]) {
-    delete env[name];
+var DEFAULT_REPO_CONCURRENCY = 4;
+var IMMUTABLE_REV = /^[0-9a-f]{40}$/;
+async function readRemoteAnchors(wants, options = {}) {
+  const out = /* @__PURE__ */ new Map();
+  if (!wants.length) return out;
+  const cacheDir = repoCacheDir(options.cacheDir);
+  const timeoutMs = fetchTimeoutMs(options.fetchTimeoutMs);
+  const byRepo = /* @__PURE__ */ new Map();
+  for (const want of wants) {
+    const key2 = normalizeRepoUrl(want.repo);
+    const group2 = byRepo.get(key2) ?? { url: want.repo.trim(), wants: [] };
+    group2.wants.push(want);
+    byRepo.set(key2, group2);
   }
-  return env;
-}
-async function git(args, options = {}) {
-  try {
-    const { stdout, stderr } = await execFileAsync2("git", args, {
-      ...options.cwd ? { cwd: options.cwd } : {},
-      timeout: options.timeoutMs ?? 3e4,
-      maxBuffer: options.maxBytes ?? MAX_ANCHOR_FILE_BYTES,
-      encoding: "utf8",
-      windowsHide: true,
-      env: childEnv()
-    });
-    return { ok: true, stdout, stderr, overflowed: false };
-  } catch (error) {
-    const failure = error;
-    return {
-      ok: false,
-      stdout: failure.stdout ?? "",
-      stderr: failure.stderr ?? "",
-      overflowed: failure.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER"
-    };
-  }
-}
-function transportReason(stderr) {
-  const text = stderr.toLowerCase();
-  if (text.includes("authentication failed") || text.includes("permission denied") || text.includes("could not read username") || text.includes("403 forbidden") || text.includes("access denied")) {
-    return "repo-unauthorized";
-  }
-  if (text.includes("couldn't find remote ref") || text.includes("unadvertised object") || text.includes("not our ref")) {
-    return "ref-not-found";
-  }
-  return "remote-unreachable";
-}
-
-// src/remote-repo/validate.ts
-var MAX_REF_LENGTH = 200;
-var REF_SHAPE = /^[A-Za-z0-9][A-Za-z0-9._/-]*$/;
-function refShapeIsSafe(ref) {
-  if (!ref || ref.length > MAX_REF_LENGTH) return false;
-  if (ref.includes("..")) return false;
-  return REF_SHAPE.test(ref);
-}
-async function refIsWellFormed(ref) {
-  if (!refShapeIsSafe(ref)) return false;
-  const checked = await git(["check-ref-format", "--allow-onelevel", ref]);
-  return checked.ok;
-}
-function filePathIsSafe(file) {
-  const path = file.replace(/^\.\//, "");
-  if (!path || path.startsWith("-") || path.includes("\0")) return false;
-  return !path.split("/").includes("..");
-}
-var DEFAULT_PROTOCOLS = ["https", "ssh", "git"];
-function allowedProtocols() {
-  const raw = process.env["STRAUSS_KB_REPO_PROTOCOLS"];
-  if (raw === void 0) return [...DEFAULT_PROTOCOLS];
-  const listed = raw.split(",").map((entry) => entry.trim().toLowerCase()).filter(Boolean);
-  return listed.length ? listed : [...DEFAULT_PROTOCOLS];
-}
-function isShortRepoName(repo) {
-  return /^[A-Za-z0-9._-]+(?:\/[A-Za-z0-9._-]+)*$/.test(repo.trim());
-}
-var SCP_LIKE = /^[\w.-]+@[\w.-]+:(?!\/)\S+$/;
-var URL_SCHEME = /^([A-Za-z0-9+.-]+):\/\//;
-var CONTROL_CHARS = /[\u0000-\u001f\u007f]/;
-function repoUrlIsSafe(repo) {
-  const url = repo.trim();
-  if (!url || url.startsWith("-") || CONTROL_CHARS.test(url)) return false;
-  const allowed = allowedProtocols();
-  if (SCP_LIKE.test(url)) return allowed.includes("ssh");
-  const scheme = URL_SCHEME.exec(url);
-  if (!scheme?.[1]) return false;
-  if (!allowed.includes(scheme[1].toLowerCase())) return false;
-  const authority = url.slice(scheme[0].length).split("/")[0] ?? "";
-  const at2 = authority.lastIndexOf("@");
-  return at2 < 0 || !authority.slice(0, at2).includes(":");
-}
-function protocolArgs() {
-  const allowed = allowedProtocols();
-  return [
-    "-c",
-    "protocol.ext.allow=never",
-    "-c",
-    `protocol.file.allow=${allowed.includes("file") ? "user" : "never"}`
-  ];
-}
-
-// src/remote-repo/read.ts
-var DEFAULT_REPO_CONCURRENCY = 4;
-var IMMUTABLE_REV = /^[0-9a-f]{40}$/;
-async function readRemoteAnchors(wants, options = {}) {
-  const out = /* @__PURE__ */ new Map();
-  if (!wants.length) return out;
-  const cacheDir = repoCacheDir(options.cacheDir);
-  const timeoutMs = fetchTimeoutMs(options.fetchTimeoutMs);
-  const byRepo = /* @__PURE__ */ new Map();
-  for (const want of wants) {
-    const key = normalizeRepoUrl(want.repo);
-    const group2 = byRepo.get(key) ?? { url: want.repo.trim(), wants: [] };
-    group2.wants.push(want);
-    byRepo.set(key, group2);
-  }
-  const groups = [...byRepo.entries()];
-  const results = await mapLimit(
-    groups,
-    Math.max(1, options.concurrency ?? DEFAULT_REPO_CONCURRENCY),
-    ([repo, group2]) => readOneRepo(repo, group2.url, group2.wants, {
-      cacheDir,
-      timeoutMs,
-      offline: options.offline === true
-    })
-  );
-  for (const result of results) {
-    for (const [key, read] of result) out.set(key, read);
-  }
-  return out;
+  const groups = [...byRepo.entries()];
+  const results = await mapLimit(
+    groups,
+    Math.max(1, options.concurrency ?? DEFAULT_REPO_CONCURRENCY),
+    ([repo, group2]) => readOneRepo(repo, group2.url, group2.wants, {
+      cacheDir,
+      timeoutMs,
+      offline: options.offline === true
+    })
+  );
+  for (const result of results) {
+    for (const [key2, read] of result) out.set(key2, read);
+  }
+  return out;
 }
 async function readOneRepo(repo, url, declared, context) {
   let wants = declared;
@@ -986,6 +1182,7 @@ function looksLikeWrongRepoRoot(drift) {
   for (const entries of drift.values()) {
     for (const entry of entries) {
       if (entry.repo !== void 0) continue;
+      if (entry.side === "old") continue;
       checked += 1;
       if (entry.state !== "unresolved" || entry.reason !== "file-missing") {
         return false;
@@ -1121,7 +1318,7 @@ function size(bytes) {
   return bytes >= 1024 * 1024 ? `${(bytes / (1024 * 1024)).toFixed(1)} MB` : `${Math.round(bytes / 1024)} KB`;
 }
 function pause(ms) {
-  return new Promise((resolve6) => setTimeout(resolve6, ms));
+  return new Promise((resolve7) => setTimeout(resolve7, ms));
 }
 
 // src/grammars/manifest.ts
@@ -1184,8 +1381,8 @@ async function ensureGrammar(language, options = {}) {
   if (!pack2) return null;
   const root = grammarsCacheRoot(options.cacheRoot);
   const wasm = grammarCachePath(root, language, pack2.wasm.sha256);
-  const key = `${wasm} ${grammarsBaseUrl(options.baseUrl) ?? ""}`;
-  const existing = inFlight.get(key);
+  const key2 = `${wasm} ${grammarsBaseUrl(options.baseUrl) ?? ""}`;
+  const existing = inFlight.get(key2);
   if (existing) return existing;
   const pending = (async () => {
     const grammar = await ensurePart(
@@ -1209,9 +1406,9 @@ ${lf(await (0, import_promises4.readFile)(path, "utf8"))}`);
     missing.delete(language);
     return { wasm, query: total ? parts.join("\n") : void 0 };
   })();
-  inFlight.set(key, pending);
+  inFlight.set(key2, pending);
   const result = await pending;
-  if (result === null) inFlight.delete(key);
+  if (result === null) inFlight.delete(key2);
   return result;
 }
 async function ensurePart(path, name, entry, options) {
@@ -1505,8 +1702,8 @@ var TreeSitterResolver = class {
   }
   /** Parsed trees are keyed by content hash, so an unchanged file parses once. */
   parse(language, loaded, source) {
-    const key = `${language}:${(0, import_node_crypto2.createHash)("sha256").update(source).digest("hex")}`;
-    const cached2 = this.trees.get(key);
+    const key2 = `${language}:${(0, import_node_crypto2.createHash)("sha256").update(source).digest("hex")}`;
+    const cached2 = this.trees.get(key2);
     if (cached2) {
       this.stats.cacheHits += 1;
       return cached2;
@@ -1530,7 +1727,7 @@ var TreeSitterResolver = class {
         this.trees.delete(oldest.value);
       }
     }
-    this.trees.set(key, parsed);
+    this.trees.set(key2, parsed);
     return parsed;
   }
   /**
@@ -1690,8 +1887,8 @@ function captureBraceBlock(lines, matchLine) {
 }
 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;
+  const header2 = lines[matchLine] ?? "";
+  const indent = header2.length - header2.trimStart().length;
   let headerEnd = -1;
   for (let index2 = matchLine; index2 < lines.length && index2 <= matchLine + 20; index2++) {
     const code = stripLine(lines[index2] ?? "", CLEAN_STATE).code.trimEnd();
@@ -1712,42 +1909,55 @@ function captureIndentedBlock(lines, matchLine) {
   }
   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*[:=]`),
+var declarationTier = (name) => new RegExp(
+  `(?:function|class|interface|type|enum|const|let|var|def)\\s+${name}\\b`
+);
+var assignmentTier = (name) => new RegExp(`\\b${name}\\s*[:=]`);
+var anchoredAssignmentTier = (name) => new RegExp(
+  `^\\s*(?:export\\s+|readonly\\s+|pub\\s+|static\\s+|private\\s+|public\\s+|protected\\s+)*${name}\\s*[:=]`
+);
+var DEFINITION_TIERS = [declarationTier, anchoredAssignmentTier];
+var MENTION_TIERS = [
   (name) => new RegExp(`\\b${name}\\s*\\(`),
   (name) => new RegExp(`\\b${name}\\b`)
 ];
+var TIERS = [declarationTier, assignmentTier, ...MENTION_TIERS];
+function resolveWith(tiers, 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, index2) => ({ line, index: index2 })).filter((entry) => pattern.test(entry.line)).map((entry) => entry.index);
+    if (!candidates.length) continue;
+    if (parentPattern && candidates.length > 1) {
+      const distances = candidates.map(
+        (index2) => distanceToParent(lines, index2, parentPattern)
+      );
+      const nearest = Math.min(...distances);
+      if (Number.isFinite(nearest)) {
+        candidates = candidates.filter((_, at2) => distances[at2] === 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;
+}
 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, index2) => ({ line, index: index2 })).filter((entry) => pattern.test(entry.line)).map((entry) => entry.index);
-      if (!candidates.length) continue;
-      if (parentPattern && candidates.length > 1) {
-        const distances = candidates.map(
-          (index2) => distanceToParent(lines, index2, parentPattern)
-        );
-        const nearest = Math.min(...distances);
-        if (Number.isFinite(nearest)) {
-          candidates = candidates.filter((_, at2) => distances[at2] === 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;
+    return resolveWith(TIERS, source, symbol);
+  },
+  attempt(source, symbol, _file, options) {
+    const tiers = options?.afterParsedMiss ? DEFINITION_TIERS : TIERS;
+    const span2 = resolveWith(tiers, source, symbol);
+    return span2 ? { kind: "resolved", span: span2 } : { kind: "unresolved", reason: "symbol-not-found" };
   }
 };
 function escapeRegExp(value) {
@@ -1765,6 +1975,7 @@ function hashAnchorText(text) {
 }
 function resolveAnchorSpan(source, anchor, resolvers = [regexResolver]) {
   const normalized = source.replace(/\r\n/g, "\n");
+  if (anchor.span) return sliceSpan(normalized, anchor.span);
   if (!anchor.symbol) {
     const lines = normalized.split("\n");
     if (lines.length > 1 && lines[lines.length - 1] === "") lines.pop();
@@ -1777,11 +1988,17 @@ function resolveAnchorSpan(source, anchor, resolvers = [regexResolver]) {
       }
     };
   }
+  let afterParsedMiss = false;
   for (const resolver of resolvers) {
-    const attempt = resolver.attempt ? resolver.attempt(normalized, anchor.symbol, anchor.file) : fromResolve(resolver, normalized, anchor.symbol, anchor.file);
+    const attempt = resolver.attempt ? resolver.attempt(normalized, anchor.symbol, anchor.file, {
+      afterParsedMiss
+    }) : fromResolve(resolver, normalized, anchor.symbol, anchor.file);
     if (attempt.kind === "abstain") continue;
     if (attempt.kind === "unresolved") {
-      if (attempt.reason === "symbol-not-found") continue;
+      if (attempt.reason === "symbol-not-found") {
+        if (resolver.attempt) afterParsedMiss = true;
+        continue;
+      }
       return { ok: false, reason: attempt.reason };
     }
     const tokens2 = resolver.normalize?.(attempt.span.text, anchor.file);
@@ -1794,12 +2011,28 @@ function resolveAnchorSpan(source, anchor, resolvers = [regexResolver]) {
   }
   return { ok: false, reason: "symbol-not-found" };
 }
+function sliceSpan(source, range) {
+  const lines = source.split("\n");
+  if (lines.length > 1 && lines[lines.length - 1] === "") lines.pop();
+  if (range.end > lines.length) {
+    return { ok: false, reason: "span-out-of-range" };
+  }
+  return {
+    ok: true,
+    span: {
+      text: lines.slice(range.start - 1, range.end).join("\n"),
+      startLine: range.start,
+      endLine: range.end
+    },
+    resolver: "span"
+  };
+}
 function fromResolve(resolver, source, symbol, file) {
   const span2 = resolver.resolve(source, symbol, file);
   return span2 ? { kind: "resolved", span: span2 } : { kind: "unresolved", reason: "symbol-not-found" };
 }
 function isResolverName(name) {
-  return name === "tree-sitter" || name === "regex";
+  return name === "tree-sitter" || name === "regex" || name === "span";
 }
 async function prepareResolvers(resolvers, files) {
   for (const resolver of resolvers) await resolver.prepare?.(files);
@@ -1818,6 +2051,9 @@ function resolverChanged(source, anchor, produced) {
   return before !== null && hashAnchorText(before.text) === anchor.hash;
 }
 function anchorHashOf(anchor, outcome) {
+  if (outcome.resolver === "span") {
+    return { hash: hashAnchorText(outcome.span.text), kind: "raw" };
+  }
   const stored = anchor.hash ? anchor.hash_kind ?? "raw" : void 0;
   const wanted = stored ?? (outcome.normalized ? "ast" : "raw");
   return wanted === "ast" && outcome.normalized ? { hash: hashAnchorText(outcome.normalized), kind: "ast" } : { hash: hashAnchorText(outcome.span.text), kind: "raw" };
@@ -1851,37 +2087,60 @@ async function detectAnchorDrift(records, options = {}) {
     }
   }
   const files = [];
+  const committedWants = [];
   const wants = [];
   for (const entries of planned.values()) {
     for (const { anchor, foreign } of entries) {
-      if (!foreign) files.push(anchor.file);
-      else wants.push(...remoteWants(anchor));
+      if (foreign) wants.push(...remoteWants(anchor));
+      else if (anchor.side === "old") committedWants.push(anchor);
+      else files.push(anchor.file);
     }
   }
-  const [reads, remote] = await Promise.all([
+  const [reads, committed, remote] = await Promise.all([
     readAnchorFiles(
       files,
       options.reader ?? anchorFileReader(repoRoot),
       options.concurrency ?? DEFAULT_IO_CONCURRENCY
     ),
+    readCommitted(repoRoot, committedWants, options),
     (options.readRemote ?? readRemoteAnchors)(wants, options.remote ?? {})
   ]);
   await prepareResolvers(resolvers, [
     ...files,
+    ...committedWants.map((anchor) => anchor.file),
     ...wants.map((want) => want.file)
   ]);
   const drift = /* @__PURE__ */ new Map();
   for (const record of records) {
     const entries = [];
     for (const { anchor, foreign } of planned.get(record.conceptId) ?? []) {
-      entries.push(
-        foreign ? remoteEntry(anchor, remote, resolvers) : localEntry(anchor, reads.get(anchor.file), resolvers)
-      );
+      if (foreign) {
+        entries.push(remoteEntry(anchor, remote, resolvers));
+        continue;
+      }
+      const read = anchor.side === "old" ? committed.get(atRefKey(anchor)) : reads.get(anchor.file);
+      entries.push(localEntry(anchor, read, resolvers));
     }
     if (entries.length) drift.set(record.conceptId, entries);
   }
   return drift;
 }
+function atRefKey(anchor) {
+  return `${anchor.ref ?? ""}\0${anchor.file}`;
+}
+async function readCommitted(repoRoot, anchors, options = {}) {
+  if (!anchors.length) return /* @__PURE__ */ new Map();
+  const read = options.readAtRef ?? readFileAtRef;
+  const byKey = /* @__PURE__ */ new Map();
+  for (const anchor of anchors) byKey.set(atRefKey(anchor), anchor);
+  const keys = [...byKey.keys()];
+  const results = await mapLimit(
+    keys,
+    options.concurrency ?? DEFAULT_IO_CONCURRENCY,
+    (key2) => read(repoRoot, byKey.get(key2))
+  );
+  return new Map(keys.map((key2, at2) => [key2, results[at2]]));
+}
 function remoteWants(anchor) {
   const repo = anchor.repo;
   const wants = [{ repo, file: anchor.file }];
@@ -1892,6 +2151,7 @@ function base(anchor) {
   return {
     file: anchor.file,
     ...anchor.symbol ? { symbol: anchor.symbol } : {},
+    ...anchor.side === "old" ? { side: "old" } : {},
     storedHash: anchor.hash
   };
 }
@@ -1905,9 +2165,15 @@ function unresolved(anchor, reason, repo) {
     ...classOf(reason)
   };
 }
+var GONE_REASONS = /* @__PURE__ */ new Set([
+  "file-missing",
+  "symbol-not-found",
+  "span-out-of-range",
+  "ref-unreadable"
+]);
 function provisionalDriftClass(entry) {
   if (entry.state === "unresolved") {
-    return entry.reason === "file-missing" || entry.reason === "symbol-not-found" ? "gone" : void 0;
+    return GONE_REASONS.has(entry.reason) ? "gone" : void 0;
   }
   return entry.state === "drifted" ? "changed" : void 0;
 }
@@ -1959,9 +2225,9 @@ function localEntry(anchor, read, resolvers) {
 }
 function remoteEntry(anchor, remote, resolvers) {
   const repo = anchor.repo;
-  const key = normalizeRepoUrl(repo);
-  const atDefault = remote.get(wantKey(key, void 0, anchor.file));
-  const primary = anchor.ref ? remote.get(wantKey(key, anchor.ref, anchor.file)) : atDefault;
+  const key2 = normalizeRepoUrl(repo);
+  const atDefault = remote.get(wantKey(key2, void 0, anchor.file));
+  const primary = anchor.ref ? remote.get(wantKey(key2, anchor.ref, anchor.file)) : atDefault;
   if (!primary) return unresolved(anchor, "remote-unreachable", repo);
   if (!primary.ok) return unresolved(anchor, primary.reason, repo);
   const found = hashIn(primary.source, anchor, resolvers);
@@ -1976,6 +2242,13 @@ function remoteEntry(anchor, remote, resolvers) {
       remoteState: "drifted-from-ref"
     });
   }
+  if (anchor.side === "old") {
+    return compared(anchor, current, {
+      repo,
+      ...extras,
+      remoteState: "matches-ref"
+    });
+  }
   const head = atDefault?.ok ? hashIn(atDefault.source, anchor, resolvers) : null;
   return head?.ok && head.current.hash !== anchor.hash ? {
     ...compared(anchor, head.current, {
@@ -2129,6 +2402,89 @@ var KbMissingFlagValueError = class extends BaseError {
   }
   flag;
 };
+var KbClassifyInputError = class extends BaseError {
+  constructor(reason) {
+    super({
+      message: `classify: ${reason}`,
+      errorType: "KbClassifyInput" /* KbClassifyInput */,
+      code: 400,
+      fault: "User" /* User */,
+      retriable: false,
+      reportToUser: true,
+      details: { reason }
+    });
+    this.reason = reason;
+  }
+  reason;
+};
+var KbPromoteCollisionError = class extends BaseError {
+  constructor(conceptId2, to) {
+    super({
+      message: `kb: ${to} already holds ${conceptId2} \u2014 re-run with force to overwrite it`,
+      errorType: "KbPromoteCollision" /* KbPromoteCollision */,
+      code: 409,
+      fault: "User" /* User */,
+      retriable: false,
+      reportToUser: true,
+      details: { conceptId: conceptId2, to, action: "refused" }
+    });
+    this.conceptId = conceptId2;
+    this.to = to;
+  }
+  conceptId;
+  to;
+};
+var KbPromoteStandingError = class extends BaseError {
+  constructor(conceptId2, standing) {
+    super({
+      message: `kb: ${conceptId2} is ${standing} \u2014 only a record that still stands can be promoted`,
+      errorType: "KbPromoteStanding" /* KbPromoteStanding */,
+      code: 409,
+      fault: "User" /* User */,
+      retriable: false,
+      reportToUser: true,
+      details: { conceptId: conceptId2, standing, action: "refused" }
+    });
+    this.conceptId = conceptId2;
+    this.standing = standing;
+  }
+  conceptId;
+  standing;
+};
+var KbPromoteSelfError = class extends BaseError {
+  constructor(to) {
+    super({
+      message: `kb: ${to} is the base being promoted from \u2014 name a different target`,
+      errorType: "KbPromoteSelf" /* KbPromoteSelf */,
+      code: 400,
+      fault: "User" /* User */,
+      retriable: false,
+      reportToUser: true,
+      details: { to, action: "refused" }
+    });
+    this.to = to;
+  }
+  to;
+};
+var KbPromoteStoppedError = class extends BaseError {
+  constructor(conceptId2, landed, reason) {
+    super({
+      message: `kb: promotion stopped at ${conceptId2} (${reason}) \u2014 landed: ${landed.length ? landed.join(", ") : "nothing"}`,
+      errorType: "KbPromoteStopped" /* KbPromoteStopped */,
+      code: 500,
+      fault: "System" /* System */,
+      retriable: false,
+      reportToUser: true,
+      details: { conceptId: conceptId2, landed, reason, action: "stopped" }
+    });
+    this.conceptId = conceptId2;
+    this.landed = landed;
+    this.reason = reason;
+  }
+  conceptId;
+  landed;
+  reason;
+};
 var KbInvalidConceptIdError = class extends BaseError {
   constructor(message, details) {
     super({
@@ -2177,8 +2533,8 @@ var KbStampDigestBaselineError = class extends BaseError {
 function asBudgets(value) {
   if (value === null || typeof value !== "object") return {};
   const table2 = value;
-  const pick = (key, min) => {
-    const raw2 = table2[key];
+  const pick = (key2, min) => {
+    const raw2 = table2[key2];
     return typeof raw2 === "number" && Number.isInteger(raw2) && raw2 >= min ? raw2 : void 0;
   };
   const budgetTokens = pick("budgetTokens", 1);
@@ -2597,6 +2953,7 @@ var anchorResolveCommand = define({
       const base2 = {
         file: anchor.file,
         ...anchor.symbol ? { symbol: anchor.symbol } : {},
+        ...anchor.side === "old" ? { side: "old" } : {},
         // Carried onto unresolved findings too: an anchor that once hashed
         // and now resolves to nothing is a broken anchor, and the exit code
         // has to be able to tell it from one nobody ever stamped.
@@ -2773,12 +3130,18 @@ async function readSources(anchors, root, offline) {
   const foreign = new Map(
     anchors.map((anchor) => [anchor, origin.isForeign(anchor)])
   );
-  const local = anchors.filter((anchor) => !foreign.get(anchor));
+  const local = anchors.filter(
+    (anchor) => !foreign.get(anchor) && anchor.side !== "old"
+  );
+  const committed = anchors.filter(
+    (anchor) => !foreign.get(anchor) && anchor.side === "old"
+  );
   const remote = anchors.filter((anchor) => foreign.get(anchor));
   const reads = await readAnchorFiles(
     local.map((anchor) => anchor.file),
     anchorFileReader(root)
   );
+  const atRef = await readCommitted(root, committed);
   const blobs = await readRemoteAnchors(remote.flatMap(remoteWants), {
     offline
   });
@@ -2790,11 +3153,18 @@ async function readSources(anchors, root, offline) {
       read.ok ? { ok: true, source: read.source } : { ok: false, reason: read.reason }
     );
   }
+  for (const anchor of committed) {
+    const read = atRef.get(atRefKey(anchor));
+    sources.set(
+      anchor,
+      read.ok ? { ok: true, source: read.source } : { ok: false, reason: read.reason }
+    );
+  }
   for (const anchor of remote) {
     const repo = anchor.repo;
-    const key = normalizeRepoUrl(repo);
-    const atDefault = blobs.get(wantKey(key, void 0, anchor.file));
-    const primary = anchor.ref ? blobs.get(wantKey(key, anchor.ref, anchor.file)) : atDefault;
+    const key2 = normalizeRepoUrl(repo);
+    const atDefault = blobs.get(wantKey(key2, void 0, anchor.file));
+    const primary = anchor.ref ? blobs.get(wantKey(key2, anchor.ref, anchor.file)) : atDefault;
     if (!primary?.ok) {
       sources.set(anchor, {
         ok: false,
@@ -2991,14 +3361,14 @@ function catalog(bundle, options = {}) {
     supersededBy: hit.heads.map((head) => head.conceptId),
     stale: hit.warnings.some((warning) => warning.kind === "stale")
   })).sort(byTypeThenTitle);
-  const standings = { ...EMPTY_STANDINGS };
-  for (const entry of entries) standings[entry.standing] += 1;
+  const standings2 = { ...EMPTY_STANDINGS };
+  for (const entry of entries) standings2[entry.standing] += 1;
   return {
     entries,
     recordCount: entries.length,
-    standings,
-    currentCount: standings.current,
-    supersededCount: standings.superseded,
+    standings: standings2,
+    currentCount: standings2.current,
+    supersededCount: standings2.superseded,
     staleCount: entries.filter((entry) => entry.stale).length
   };
 }
@@ -3095,473 +3465,347 @@ function count(value, noun) {
   return `${value} ${value === 1 ? noun : `${noun}s`}`;
 }
 
-// src/commands/context.ts
-var import_zod11 = require("zod");
-
-// src/kb-context.ts
-var import_promises6 = require("fs/promises");
-
-// src/kb-index.ts
-var INDEX_FILE = "INDEX.md";
-var HEADING = "# KB Index";
-function renderIndex(records) {
-  const lines = [...records].sort((left, right) => left.conceptId.localeCompare(right.conceptId)).map(renderIndexLine);
-  return `${HEADING}
+// src/commands/classify.ts
+var import_node_buffer = require("buffer");
+var import_promises7 = require("fs/promises");
+var import_node_path10 = require("path");
+var import_zod13 = require("zod");
 
-${lines.join("\n")}
-`;
+// src/match-diff.ts
+function matchToDiff(files, records, options = {}) {
+  const ranges = symbolRangeIndex(options.symbolRanges ?? []);
+  const anchored = records.filter(
+    (record) => (record.frontmatter.strauss_anchors ?? []).length > 0
+  );
+  const matches3 = [];
+  for (const file of files) {
+    const candidates = anchored.map((record) => ({
+      record,
+      anchors: (record.frontmatter.strauss_anchors ?? []).filter(
+        (anchor) => normalize(anchor.file) === normalize(file.filePath)
+      )
+    })).filter(({ anchors }) => anchors.length > 0);
+    if (!candidates.length) continue;
+    for (const hunk of file.hunks) {
+      const hits = [];
+      let precision = "symbol";
+      for (const { record, anchors } of candidates) {
+        const placement = place(anchors, file.filePath, hunk, ranges);
+        if (placement.kind === "miss") continue;
+        if (placement.kind === "file") precision = "file";
+        hits.push(record);
+      }
+      if (!hits.length) continue;
+      matches3.push({
+        filePath: file.filePath,
+        hunk,
+        records: order(adjudicate(hits, records, options.now)),
+        precision
+      });
+    }
+  }
+  return matches3;
 }
-function renderIndexLine(record) {
-  const { frontmatter: fm } = record;
-  const parts = [fm.type, fm.strauss_status];
-  if (fm.tags?.length) parts.push(`tags: ${fm.tags.join(", ")}`);
-  if (fm.description) parts.push(fm.description);
-  return `- [${fm.title ?? record.conceptId}](${record.conceptId}.md) \u2014 ${parts.join(" \xB7 ")}`;
+function placeOnHunk(record, filePath, hunk, symbolRanges = []) {
+  const anchors = (record.frontmatter.strauss_anchors ?? []).filter(
+    (anchor) => normalize(anchor.file) === normalize(filePath)
+  );
+  return place(anchors, filePath, hunk, asIndex(symbolRanges));
+}
+function asIndex(ranges) {
+  return isIndex(ranges) ? ranges : symbolRangeIndex(ranges);
+}
+function isIndex(ranges) {
+  return !Array.isArray(ranges);
+}
+function place(anchors, filePath, hunk, ranges) {
+  let fallback = { kind: "miss" };
+  for (const anchor of anchors) {
+    if (side(anchor.side) !== side(hunk.side)) continue;
+    if (anchor.span) {
+      if (overlaps(
+        { startLine: anchor.span.start, endLine: anchor.span.end },
+        hunk
+      )) {
+        return { kind: "symbol", anchor };
+      }
+      continue;
+    }
+    if (!anchor.symbol) return { kind: "file", anchor };
+    const resolved = ranges.get(
+      key(filePath, anchor.symbol, side(anchor.side))
+    );
+    if (!resolved?.length) {
+      if (fallback.kind === "miss") fallback = { kind: "file", anchor };
+      continue;
+    }
+    if (resolved.some((range) => overlaps(range, hunk))) {
+      return { kind: "symbol", anchor };
+    }
+  }
+  return fallback;
 }
-function indexIsStale(stored, expected) {
-  return stored !== expected;
+function side(value) {
+  return value ?? "new";
+}
+function overlaps(range, hunk) {
+  return range.startLine <= hunk.endLine && hunk.startLine <= range.endLine;
+}
+function order(records) {
+  const rank = {
+    current: 0,
+    unsettled: 1,
+    open: 2,
+    superseded: 3,
+    rejected: 4
+  };
+  return [...records].sort(
+    (left, right) => (rank[left.standing] ?? 9) - (rank[right.standing] ?? 9) || (left.record.frontmatter.generated?.at ?? "").localeCompare(
+      right.record.frontmatter.generated?.at ?? ""
+    )
+  );
+}
+function symbolRangeIndex(ranges) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const range of ranges) {
+    const id = key(range.file, range.symbol, side(range.side));
+    byKey.set(id, [...byKey.get(id) ?? [], range]);
+  }
+  return byKey;
+}
+function key(file, symbol, at2) {
+  return `${normalize(file)}#${symbol}#${at2}`;
+}
+function normalize(path) {
+  return path.replace(/^\.\//, "");
 }
 
-// src/kb-context.ts
-var HEADING2 = "## Knowledge bases (pinned)";
-var DEFAULT_CONTEXT_BUDGET = 4e3;
-var CONTEXT_PROFILES = {
-  "session-start": { fullUnderTokens: 1500 },
-  compact: { budgetTokens: 2500 },
-  turn: { budgetTokens: 2500 }
+// src/classify/model.ts
+var DEFAULT_THRESHOLDS = {
+  boilerplate: 0.8,
+  rename: 90
 };
-function approxTokens(text) {
-  return Math.ceil(text.length / 4);
-}
-function preamble() {
-  return [
-    HEADING2,
-    "",
-    "What follows is an index of this workspace's pinned knowledge bases \u2014",
-    "concept ids, titles and standing only. The record bodies are NOT in this",
-    "context.",
-    "",
-    "Consult records only through the strauss-kb MCP tools: `kb_load` (the",
-    "preferred first call), `kb_query`, and `kb_trace`, passing the",
-    "`bundlePath` listed with each base. Do not read record files directly:",
-    "a raw file read bypasses supersession resolution, and a superseded or",
-    "rejected record file reads exactly like a current one \u2014 only the store",
-    "resolves chains and standing.",
-    "",
-    "KB content loaded earlier in a long session may have been compacted",
-    "away. Before answering a question one of these bases governs, load it",
-    "again at the point of use \u2014 reloading a small base costs a few thousand",
-    "tokens."
-  ].join("\n");
-}
-async function renderBase(store, path, absolutePath, fullUnderTokens, pinMode, budgetTokens, excludeTags) {
-  const bundle = await store.list(absolutePath);
-  if (bundle.length === 0) {
-    return {
-      path,
-      absolutePath,
-      mode: "empty",
-      body: "No readable records yet \u2014 pinned ahead of being populated."
-    };
+
+// src/classify/rules.ts
+var PATH_RULES = [
+  {
+    name: "test-path",
+    class: "test",
+    test: /(^|\/)(__tests__|__mocks__|tests?)\/|\.(spec|test)\.[^/]+$/
+  },
+  {
+    name: "ci-path",
+    class: "ci",
+    test: /(^|\/)\.github\/|(^|\/)(\.circleci|\.buildkite|\.gitlab|ci)\/[^/]*\.ya?ml$|(^|\/)Dockerfile(\.[^/]*)?$|\.tf$/
+  },
+  {
+    name: "docs-path",
+    class: "docs",
+    test: /\.md$|(^|\/)docs\/|(^|\/)LICENSE(\.(md|txt|rst))?$/
+  },
+  {
+    name: "lockfile-path",
+    class: "lockfile",
+    test: /(^|\/)(pnpm-lock\.yaml|package-lock\.json|yarn\.lock|Cargo\.lock|go\.sum)$/
+  },
+  {
+    name: "config-path",
+    class: "config",
+    // `.jsonl` rides with `.json`: an append-only log of JSON is configuration
+    // data too, and calling it source would send a reviewer to read it. Every
+    // arm is anchored at both ends: `src/tsconfig-loader.ts` and `report.env.ts`
+    // are source, not config.
+    test: /\.(jsonc?|jsonl|ya?ml|toml|ini)$|(^|\/)\.env(?![^/]*\.[cm]?[jt]sx?$)([.-][^/]*)?$|[^/]+\.env$|(^|\/)tsconfig[^/]*\.json$|\.config\.[^/]+$|(^|\/)\.(eslintrc|prettierrc)[^/]*$/
   }
-  const fullCap = pinMode === "full" ? budgetTokens : pinMode === "index" ? 0 : fullUnderTokens;
-  let degradedFrom;
-  if (fullCap > 0) {
-    const full = await store.load(absolutePath, {
-      budgetTokens: fullCap,
-      excludeTags
-    });
-    if (!full.loaded && pinMode === "full") {
-      degradedFrom = { approxTokens: full.approxTokens };
-    }
-    if (full.loaded) {
-      const records = full.records.map(
-        (hit) => [
-          `#### ${hit.record.conceptId} \u2014 ${hit.record.frontmatter.title ?? "(untitled)"} (${hit.standing})`,
-          "",
-          hit.record.body.trim()
-        ].join("\n")
-      );
-      const superseded2 = full.superseded.map(
-        (entry) => `- \`${entry.conceptId}\` \u2192 superseded by ${entry.supersededBy.map((id) => `\`${id}\``).join(", ") || "(missing replacement)"}`
-      );
-      return {
-        path,
-        absolutePath,
-        mode: "full",
-        body: [
-          ...records,
-          ...superseded2.length ? [
-            "#### Superseded (bodies withheld \u2014 kb_trace reaches them)",
-            ...superseded2
-          ] : []
-        ].join("\n\n")
-      };
-    }
+];
+var HEADER_LINES = 20;
+var GENERATED_MARKERS = [
+  /@generated\b/i,
+  /\bdo not edit\b/i,
+  /\bcode generated by\b/i,
+  /\bthis file was automatically generated\b/i
+];
+var BOILERPLATE_SHAPES = [
+  { name: "import", test: /^import\b|^\}\s*from\s+["']/ },
+  { name: "re-export", test: /^export\s+(\*|\{|type\s*[{*])/ },
+  {
+    name: "class-shell",
+    test: /^(export\s+)?(default\s+)?(abstract\s+)?class\s+[\w$]+[^{]*\{\s*\}$/
+  },
+  { name: "punctuation", test: /^[{}()[\],;]+$/ }
+];
+function generatedMarker(lines) {
+  for (const line of lines.slice(0, HEADER_LINES)) {
+    const hit = GENERATED_MARKERS.find((marker) => marker.test(line));
+    if (hit) return hit.source.replaceAll("\\b", "");
   }
-  const adjudicated = adjudicate(bundle, bundle).filter(
-    (hit) => matchesTags(hit.record, { excludeTags })
-  );
-  const lines = adjudicated.filter((hit) => hit.standing !== "superseded").map((hit) => renderIndexLine(hit.record));
-  const superseded = adjudicated.filter((hit) => hit.standing === "superseded").map(
-    (hit) => `- \`${hit.record.conceptId}\` \u2192 superseded by ${hit.heads.map((head) => `\`${head.conceptId}\``).join(", ") || "(missing replacement)"}`
+  return void 0;
+}
+function isBoilerplateLine(line) {
+  return BOILERPLATE_SHAPES.some((shape) => shape.test.test(line));
+}
+
+// src/classify/classify.ts
+function classifyDiff(files, options = {}) {
+  const overrides = currentOverrides(options.records ?? [], options.now);
+  const ranges = symbolRangeIndex(options.symbolRanges ?? []);
+  const thresholds = { ...DEFAULT_THRESHOLDS, ...options.thresholds };
+  return files.map((file) => classifyFile(file, overrides, ranges, thresholds));
+}
+var OVERRIDE_CLASS = /* @__PURE__ */ new Map([
+  ["review:generated", "generated"],
+  ["review:boilerplate", "boilerplate"],
+  ["review:move", "rename"]
+]);
+var WHOLE_FILE = {
+  startLine: 1,
+  endLine: Number.MAX_SAFE_INTEGER
+};
+function classifyFile(file, overrides, ranges, thresholds) {
+  const whole = overrides.find(
+    ({ record }) => placeOnHunk(record, file.filePath, WHOLE_FILE, ranges).kind === "file"
   );
+  const verdict = whole ? verdictOf(whole) : heuristic(file, thresholds);
+  const hunks = file.hunks.map((hunk) => {
+    const hit = whole ?? overrides.find(
+      ({ record }) => placeOnHunk(record, file.filePath, hunk, ranges).kind !== "miss"
+    );
+    return {
+      startLine: hunk.startLine,
+      endLine: hunk.endLine,
+      ...hit ? verdictOf(hit) : verdict
+    };
+  });
   return {
-    path,
-    absolutePath,
-    mode: "index",
-    body: [...lines, ...superseded].join("\n"),
-    ...degradedFrom ? { degradedFrom } : {}
+    filePath: file.filePath,
+    ...verdict,
+    ...file.renamedFrom ? { renamedFrom: file.renamedFrom } : {},
+    ...hunks.some((hunk) => hunk.class !== verdict.class) ? { hunks } : {}
   };
 }
-async function buildContext(store, workspaceDir, options = {}) {
-  const builtin = options.profile ? CONTEXT_PROFILES[options.profile] ?? {} : {};
-  let budgetTokens = options.budgetTokens ?? builtin.budgetTokens ?? DEFAULT_CONTEXT_BUDGET;
-  let fullUnderTokens = options.fullUnderTokens ?? builtin.fullUnderTokens ?? 0;
-  const merged = await readMergedPins(workspaceDir);
-  const fromManifest = mergedContextBudgets(merged, options.profile);
-  budgetTokens = options.budgetTokens ?? fromManifest.budgetTokens ?? builtin.budgetTokens ?? DEFAULT_CONTEXT_BUDGET;
-  fullUnderTokens = options.fullUnderTokens ?? fromManifest.fullUnderTokens ?? builtin.fullUnderTokens ?? 0;
-  const excludeTags = options.excludeTags ?? fromManifest.excludeTags ?? builtin.excludeTags ?? [];
-  const pins = merged.pins.filter(
-    (pin) => !pin.profiles?.length || !options.profile || pin.profiles.includes(options.profile)
-  );
-  if (pins.length === 0) {
+function verdictOf(override) {
+  return {
+    class: override.class,
+    reason: `kb-override ${override.record.conceptId}`
+  };
+}
+function heuristic(file, thresholds) {
+  const marker = generatedMarker(file.header ?? headOfDiff(file));
+  if (marker)
+    return { class: "generated", reason: `generated-header ${marker}` };
+  const rule = PATH_RULES.find((entry) => entry.test.test(file.filePath));
+  if (rule) return { class: rule.class, reason: rule.name };
+  if (file.renamedFrom && !file.hunks.length && (file.similarity ?? 100) >= thresholds.rename) {
+    return { class: "rename", reason: `rename ${file.renamedFrom}` };
+  }
+  const share = boilerplateShare(file);
+  if (share !== void 0 && share >= thresholds.boilerplate) {
     return {
-      block: "",
-      refused: false,
-      approxTokens: 0,
-      budgetTokens,
-      bases: []
+      class: "boilerplate",
+      reason: `boilerplate ${Math.round(share * 100)}%`
     };
   }
-  const sections = await Promise.all(
-    pins.map(async (pin) => ({
-      section: await renderBase(
-        store,
-        pin.path,
-        pin.absolutePath,
-        fullUnderTokens,
-        pin.mode,
-        budgetTokens,
-        excludeTags
-      ),
-      frozen: pin.frozen === true
-    }))
+  return { class: "source", reason: "default" };
+}
+function headOfDiff(file) {
+  return file.hunks.flatMap(
+    (hunk) => (hunk.side ?? "new") === "new" && hunk.startLine <= HEADER_LINES ? (hunk.lines ?? []).slice(0, HEADER_LINES - hunk.startLine + 1) : []
   );
-  const modeLabel = {
-    index: "index only \u2014 record bodies are not here",
-    full: "full records \u2014 this base arrives whole",
-    empty: "empty"
+}
+function boilerplateShare(file) {
+  const lines = file.hunks.flatMap((hunk) => hunk.lines ?? []).map((line) => line.trim()).filter(Boolean);
+  if (!lines.length) return void 0;
+  return lines.filter(isBoilerplateLine).length / lines.length;
+}
+function currentOverrides(records, now) {
+  const tagged = records.flatMap((record) => {
+    if (record.frontmatter.type !== "fact") return [];
+    const tag = (record.frontmatter.tags ?? []).find(
+      (entry) => OVERRIDE_CLASS.has(entry)
+    );
+    const asserted = tag && OVERRIDE_CLASS.get(tag);
+    return asserted ? [{ record, class: asserted }] : [];
+  });
+  const current = new Set(
+    adjudicate(
+      tagged.map(({ record }) => record),
+      records,
+      now
+    ).filter((entry) => entry.standing === "current").map((entry) => entry.record.conceptId)
+  );
+  return tagged.filter(({ record }) => current.has(record.conceptId)).sort(
+    (left, right) => left.record.conceptId.localeCompare(right.record.conceptId)
+  );
+}
+
+// src/drift/moved.ts
+var import_promises6 = require("fs/promises");
+var MAX_MOVED_SEARCH_FILES = 2e3;
+var SEARCH_BATCH = 64;
+function movedSearch(repoRoot, options = {}) {
+  const read = options.reader ?? anchorFileReader(repoRoot);
+  const sizeOf = options.sizeOf ?? diskSize(repoRoot);
+  const resolver = new TreeSitterResolver();
+  let repoFiles;
+  const prepared = /* @__PURE__ */ new Set();
+  const filesForLanguage = async (language) => {
+    repoFiles ??= listRepoFiles(repoRoot);
+    return (await repoFiles).filter((file) => languageForFile(file) === language).slice(0, MAX_MOVED_SEARCH_FILES);
   };
-  for (const { section } of sections) {
-    if (section.degradedFrom) {
-      options.warn?.({
-        operation: "kb.context.full-pin-degraded",
-        path: section.path,
-        approxTokens: section.degradedFrom.approxTokens,
-        budgetTokens
-      });
+  return {
+    async find(anchor) {
+      const stored = anchor.hash;
+      if (!stored) return void 0;
+      if (anchor.span) return sameFileWindow(anchor, read, stored);
+      const language = languageForFile(anchor.file);
+      if (!language) return sameFileWindow(anchor, read, stored);
+      const candidates = await filesForLanguage(language);
+      if (!prepared.has(language)) {
+        await resolver.prepare(candidates.length ? candidates : [anchor.file]);
+        prepared.add(language);
+      }
+      const floor = anchor.lines ?? 0;
+      for (let at2 = 0; at2 < candidates.length; at2 += SEARCH_BATCH) {
+        const batch = candidates.slice(at2, at2 + SEARCH_BATCH);
+        const hits = await mapLimit(
+          batch,
+          DEFAULT_IO_CONCURRENCY,
+          async (file) => {
+            const size2 = await sizeOf(file);
+            if (size2 !== null && size2 < floor) return void 0;
+            return matchIn(resolver, read, anchor, stored, file);
+          }
+        );
+        const found = hits.find((hit) => hit !== void 0);
+        if (found) return found;
+      }
+      return void 0;
     }
-  }
-  const rendered = sections.map(({ section, frozen }) => {
-    const label = section.degradedFrom ? `index only \u2014 pinned \`mode: full\`, but its ~${section.degradedFrom.approxTokens} tokens exceed this block's ${budgetTokens}-token budget; kb_load it directly (load's budget is separate), or raise this profile's budget` : modeLabel[section.mode];
-    return [
-      `### ${section.path} (${label}${frozen ? " \xB7 frozen, read-only" : ""})`,
-      "",
-      `bundlePath: \`${section.absolutePath}\``,
-      "",
-      section.body
-    ].join("\n");
-  });
-  const block = [preamble(), "", rendered.join("\n\n"), ""].join("\n");
-  const bases = sections.map(({ section }) => ({
-    path: section.path,
-    absolutePath: section.absolutePath,
-    approxTokens: approxTokens(section.body)
-  }));
-  const total = approxTokens(block);
-  if (total > budgetTokens) {
-    options.warn?.({
-      operation: "kb.context.refused",
-      approxTokens: total,
-      budgetTokens,
-      bases: bases.map((base2) => base2.path)
-    });
-    const refusal = [
-      HEADING2,
-      "",
-      `The pinned index runs to ~${total} tokens, past the ${budgetTokens}-token`,
-      "budget, and was not emitted \u2014 a truncated index is indistinguishable",
-      "from a complete one. The pinned bases:",
-      "",
-      ...bases.map(
-        (base2) => `- ${base2.path} \u2014 ~${base2.approxTokens} tokens (bundlePath: \`${base2.absolutePath}\`)`
-      ),
-      "",
-      "For the question at hand, read what you need now \u2014 `kb_load` a base",
-      "(its own budget is separate), or `kb_index` for one base's shape.",
-      "",
-      "To bring this block back under budget, in order of preference:",
-      "- supersede or resolve stale records \u2014 the base shrinks, the knowledge keeps",
-      "- force a large base to index lines: `strauss-kb pin <path> --mode index`",
-      "- scope a pin to the profiles that need it: `strauss-kb pin <path> --profiles session-start`",
-      "- raise this profile's budget under `context` in .strauss/kb-pins.json",
-      "- unpin what no session actually needs",
-      ""
-    ].join("\n");
+  };
+}
+async function matchIn(resolver, read, anchor, stored, file) {
+  const source = await read(file);
+  if (!source.ok) return void 0;
+  const normalized = source.source.replace(/\r\n/g, "\n");
+  for (const found of resolver.spans(normalized, file)) {
+    const text = anchor.hash_kind === "ast" ? resolver.normalize(found.span.text, file) : found.span.text;
+    if (text === null || hashAnchorText(text) !== stored) continue;
+    if (file === anchor.file && found.symbol === anchor.symbol) continue;
     return {
-      block: refusal,
-      refused: true,
-      approxTokens: total,
-      budgetTokens,
-      bases
+      file,
+      symbol: found.symbol,
+      startLine: found.span.startLine,
+      endLine: found.span.endLine
     };
   }
-  return { block, refused: false, approxTokens: total, budgetTokens, bases };
-}
-function toHookJson(block, event) {
-  return JSON.stringify({
-    hookSpecificOutput: {
-      hookEventName: event,
-      additionalContext: block
-    }
-  });
-}
-var CONTEXT_BEGIN = "<!-- strauss-kb:begin -->";
-var CONTEXT_END = "<!-- strauss-kb:end -->";
-async function syncInstructions(file, block) {
-  const existing = await (0, import_promises6.readFile)(file, "utf8").catch(() => null);
-  const region = block ? `${CONTEXT_BEGIN}
-${block.trim()}
-${CONTEXT_END}` : null;
-  if (existing === null) {
-    if (!region) return { file, action: "unchanged" };
-    await (0, import_promises6.writeFile)(file, `${region}
-`, "utf8");
-    return { file, action: "created" };
-  }
-  const begin = existing.indexOf(CONTEXT_BEGIN);
-  const end = existing.indexOf(CONTEXT_END);
-  if (begin !== -1 && end !== -1 && end >= begin) {
-    const before = existing.slice(0, begin);
-    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_promises6.writeFile)(file, next, "utf8");
-    return { file, action: region ? "replaced" : "removed" };
-  }
-  if (!region) return { file, action: "unchanged" };
-  await (0, import_promises6.writeFile)(
-    file,
-    `${existing.replace(/\n*$/, "\n\n")}${region}
-`,
-    "utf8"
-  );
-  return { file, action: "appended" };
-}
-
-// src/commands/context.ts
-var contextCommand = define({
-  name: "context",
-  tool: "kb_context",
-  usage: "context [--profile NAME] [--budget N] [--full-under N] [--exclude-tag T]... [--format json] [--event NAME]",
-  description: "Index block of pinned bases (ids, titles, standing) for injection at context birth. Takes no bundlePath \u2014 reads the workspace pin manifests. Empty when nothing is pinned; refuses over budget rather than truncating. Budget precedence: flags, then the manifest `context[profile]` over `context.default`, then the built-in profile, then package defaults.",
-  input: import_zod11.z.object({
-    budgetTokens: import_zod11.z.number().int().positive().optional().describe(
-      "Ceiling on the whole emitted block; past it the command refuses with a list of bases rather than truncating. Defaults to 4000."
-    ),
-    fullUnderTokens: import_zod11.z.number().int().positive().optional().describe(
-      "Per-base rendering threshold, applied before the budget: a base whose complete load fits under this arrives as full records instead of index lines, and the whole block still answers to budgetTokens. Off by default \u2014 index-only is the safe default at a context birth, because injected bodies outlive the qualifiers on them; the session-start profile opts tiny bases in at 1500."
-    ),
-    profile: import_zod11.z.string().optional().describe(
-      "Named budget set: built-ins are session-start (full-under 1500), compact and turn (budget 2500); the manifests' `context` tables override per repo. Unknown names fall through to defaults rather than failing."
-    ),
-    excludeTags: import_zod11.z.array(import_zod11.z.string().min(1)).optional().describe(
-      "Frontmatter tags whose records stay out of the block. The base stays pinned and stays readable by tool; resolved like the budgets."
-    ),
-    format: import_zod11.z.enum(["markdown", "json"]).optional().describe(
-      "CLI envelope for hook protocols that require strict JSON on stdout. MCP callers omit this \u2014 the block itself is identical."
-    ),
-    event: import_zod11.z.string().optional().describe(
-      "hookEventName stamped into the JSON envelope. Only meaningful with format=json."
-    )
-  }),
-  fromArgv: (argv) => {
-    const budget = argvFlag(argv, "--budget");
-    const fullUnder = argvFlag(argv, "--full-under");
-    const profile = argvFlag(argv, "--profile");
-    const format = argvFlag(argv, "--format");
-    const event = argvFlag(argv, "--event");
-    const excludeTags = argvFlags(argv, "--exclude-tag");
-    return {
-      ...budget ? { budgetTokens: Number(budget) } : {},
-      ...fullUnder ? { fullUnderTokens: Number(fullUnder) } : {},
-      ...profile ? { profile } : {},
-      ...excludeTags.length ? { excludeTags } : {},
-      ...format ? { format } : {},
-      ...event ? { event } : {}
-    };
-  },
-  run: async ({ store }, { budgetTokens, fullUnderTokens, profile, excludeTags, format, event }) => {
-    const result = await buildContext(store, process.cwd(), {
-      ...budgetTokens ? { budgetTokens } : {},
-      ...fullUnderTokens ? { fullUnderTokens } : {},
-      ...profile ? { profile } : {},
-      ...excludeTags ? { excludeTags } : {},
-      // Degradations — a full pin that could not fit, a refused block — go
-      // to stderr as well as into the block itself: stderr is diagnostics on
-      // both surfaces (hooks discard it, MCP logs it), so an operator can
-      // see budget pressure without reading injected context.
-      warn: (entry) => process.stderr.write(`${JSON.stringify(entry)}
-`)
-    });
-    if (!result.block) return "";
-    return format === "json" ? toHookJson(result.block, event ?? "SessionStart") : result.block;
-  }
-});
-
-// src/commands/doctor.ts
-var import_zod13 = require("zod");
-
-// src/drift/git.ts
-var import_node_child_process3 = require("child_process");
-var import_node_util3 = require("util");
-var execFileAsync3 = (0, import_node_util3.promisify)(import_node_child_process3.execFile);
-var MAX_GIT_OUTPUT_BYTES = 1048576;
-var GIT_TIMEOUT_MS = 5e3;
-async function git2(cwd, args) {
-  const env = { ...process.env };
-  delete env["GIT_DIR"];
-  delete env["GIT_WORK_TREE"];
-  delete env["GIT_INDEX_FILE"];
-  try {
-    const { stdout } = await execFileAsync3("git", ["-C", cwd, ...args], {
-      timeout: GIT_TIMEOUT_MS,
-      maxBuffer: MAX_GIT_OUTPUT_BYTES,
-      env
-    });
-    return { ok: true, stdout };
-  } catch {
-    return { ok: false };
-  }
-}
-async function listRepoFiles(repoRoot) {
-  const result = await git2(repoRoot, ["ls-files", "-z", "--cached"]);
-  if (!result.ok) return [];
-  return result.stdout.split("\0").filter(Boolean);
-}
-async function readOldSource(repoRoot, anchor) {
-  if (!filePathIsSafe(anchor.file))
-    return { ok: false, reason: "unrecoverable" };
-  if (anchor.ref && refShapeIsSafe(anchor.ref)) {
-    const shown2 = await showFile(repoRoot, anchor.ref, anchor.file);
-    if (shown2 !== null) {
-      return {
-        ok: true,
-        source: shown2,
-        origin: { kind: "ref", ref: anchor.ref }
-      };
-    }
-  }
-  const at2 = anchor.resolved_at;
-  if (!at2 || Number.isNaN(Date.parse(at2))) {
-    return { ok: false, reason: "unrecoverable" };
-  }
-  const found = await git2(repoRoot, [
-    "log",
-    "-1",
-    "--format=%H",
-    `--before=${at2}`,
-    "--end-of-options",
-    "HEAD",
-    "--",
-    anchor.file
-  ]);
-  const sha = found.ok ? found.stdout.trim() : "";
-  if (!sha || !refShapeIsSafe(sha))
-    return { ok: false, reason: "unrecoverable" };
-  const shown = await showFile(repoRoot, sha, anchor.file);
-  if (shown === null) return { ok: false, reason: "unrecoverable" };
-  return { ok: true, source: shown, origin: { kind: "history", ref: sha } };
-}
-async function showFile(repoRoot, ref, file) {
-  const path = file.replace(/^\.\//, "");
-  const result = await git2(repoRoot, [
-    "show",
-    "--end-of-options",
-    `${ref}:${path}`
-  ]);
-  return result.ok ? result.stdout : null;
-}
-
-// src/drift/moved.ts
-var import_promises7 = require("fs/promises");
-var MAX_MOVED_SEARCH_FILES = 2e3;
-var SEARCH_BATCH = 64;
-function movedSearch(repoRoot, options = {}) {
-  const read = options.reader ?? anchorFileReader(repoRoot);
-  const sizeOf = options.sizeOf ?? diskSize(repoRoot);
-  const resolver = new TreeSitterResolver();
-  let repoFiles;
-  const prepared = /* @__PURE__ */ new Set();
-  const filesForLanguage = async (language) => {
-    repoFiles ??= listRepoFiles(repoRoot);
-    return (await repoFiles).filter((file) => languageForFile(file) === language).slice(0, MAX_MOVED_SEARCH_FILES);
-  };
-  return {
-    async find(anchor) {
-      const stored = anchor.hash;
-      if (!stored) return void 0;
-      const language = languageForFile(anchor.file);
-      if (!language) return sameFileWindow(anchor, read, stored);
-      const candidates = await filesForLanguage(language);
-      if (!prepared.has(language)) {
-        await resolver.prepare(candidates.length ? candidates : [anchor.file]);
-        prepared.add(language);
-      }
-      const floor = anchor.lines ?? 0;
-      for (let at2 = 0; at2 < candidates.length; at2 += SEARCH_BATCH) {
-        const batch = candidates.slice(at2, at2 + SEARCH_BATCH);
-        const hits = await mapLimit(
-          batch,
-          DEFAULT_IO_CONCURRENCY,
-          async (file) => {
-            const size2 = await sizeOf(file);
-            if (size2 !== null && size2 < floor) return void 0;
-            return matchIn(resolver, read, anchor, stored, file);
-          }
-        );
-        const found = hits.find((hit) => hit !== void 0);
-        if (found) return found;
-      }
-      return void 0;
-    }
-  };
-}
-async function matchIn(resolver, read, anchor, stored, file) {
-  const source = await read(file);
-  if (!source.ok) return void 0;
-  const normalized = source.source.replace(/\r\n/g, "\n");
-  for (const found of resolver.spans(normalized, file)) {
-    const text = anchor.hash_kind === "ast" ? resolver.normalize(found.span.text, file) : found.span.text;
-    if (text === null || hashAnchorText(text) !== stored) continue;
-    if (file === anchor.file && found.symbol === anchor.symbol) continue;
-    return {
-      file,
-      symbol: found.symbol,
-      startLine: found.span.startLine,
-      endLine: found.span.endLine
-    };
-  }
-  return void 0;
+  return void 0;
 }
 function diskSize(repoRoot) {
   return async (file) => {
     const path = anchorFilePath(repoRoot, file);
     if (path === null) return null;
     try {
-      return (await (0, import_promises7.stat)(path)).size;
+      return (await (0, import_promises6.stat)(path)).size;
     } catch {
       return null;
     }
@@ -3610,6 +3854,11 @@ async function classifyDrift(repoRoot, record, entries, options = {}) {
   );
   const out = [];
   for (const { anchor, entry } of wanted) {
+    if (anchor.side === "old") {
+      const settled2 = entry.class ?? "changed";
+      out.push({ anchor, entry: { ...entry, class: settled2 }, class: settled2 });
+      continue;
+    }
     const movedTo = await search.find(anchor);
     if (movedTo) {
       out.push({
@@ -3683,8 +3932,8 @@ function unifiedDiff(before, after, options = {}) {
   }
   const truncated = body.length > max;
   const shown = truncated ? body.slice(0, max) : body;
-  const header = `@@ -1,${left.length} +1,${right.length} @@${options.oldLabel ? ` ${options.oldLabel} \u2192 ${options.newLabel ?? ""}`.trimEnd() : ""}`;
-  const lines = [header, ...shown];
+  const header2 = `@@ -1,${left.length} +1,${right.length} @@${options.oldLabel ? ` ${options.oldLabel} \u2192 ${options.newLabel ?? ""}`.trimEnd() : ""}`;
+  const lines = [header2, ...shown];
   if (truncated) lines.push(`\u2026 ${body.length - max} more diff lines`);
   return { text: lines.join("\n"), added, removed, truncated };
 }
@@ -3744,12 +3993,12 @@ async function reassessPacket(repoRoot, record, entries, options = {}) {
     ...options.search ? { search: options.search } : {},
     withHistory: options.withDiff !== false
   });
-  const open = classified.filter(
+  const open2 = classified.filter(
     (found) => found.class === "changed" || found.class === "gone"
   );
-  if (!open.length) return { packet: null, classified };
-  const budget = diffBudget(open.length);
-  const anchors = open.map(
+  if (!open2.length) return { packet: null, classified };
+  const budget = diffBudget(open2.length);
+  const anchors = open2.map(
     (found) => anchorPacket(found, options.withDiff === true, budget)
   );
   const type = record.frontmatter.type;
@@ -3788,41 +4037,893 @@ function anchorPacket(found, withDiff, maxLines) {
     diffSize: entry.diffSize,
     ...entry.movedTo ? { movedTo: entry.movedTo } : {}
   };
-  if (!withDiff) return base2;
-  if (found.oldText === void 0 || !found.oldOrigin) {
-    return { ...base2, diff: { status: "unrecoverable" } };
+  if (!withDiff) return base2;
+  if (found.oldText === void 0 || !found.oldOrigin) {
+    return { ...base2, diff: { status: "unrecoverable" } };
+  }
+  const rendered = unifiedDiff(found.oldText, found.newText ?? "", {
+    maxLines
+  });
+  return {
+    ...base2,
+    diff: {
+      status: "ok",
+      source: found.oldOrigin.kind,
+      ref: found.oldOrigin.ref,
+      unified: rendered.text,
+      added: rendered.added,
+      removed: rendered.removed,
+      truncated: rendered.truncated
+    }
+  };
+}
+function claimOf(record) {
+  const type = record.frontmatter.type;
+  const section = isKbRecordType(type) ? RECORD_TYPES[type].sections[0] : void 0;
+  if (!section) return null;
+  const lines = record.body.replace(/\r\n/g, "\n").split("\n");
+  const start = lines.findIndex(
+    (line) => line.trim().toLowerCase() === `## ${section}`.toLowerCase()
+  );
+  if (start < 0) return null;
+  const rest = lines.slice(start + 1);
+  const end = rest.findIndex((line) => line.startsWith("## "));
+  const text = (end < 0 ? rest : rest.slice(0, end)).join("\n").trim();
+  return text ? { section, text } : null;
+}
+
+// src/commands/match/command.ts
+var import_zod12 = require("zod");
+
+// src/commands/match/errors.ts
+var KbMatchInputError = class extends BaseError {
+  constructor(reason) {
+    super({
+      message: `match: ${reason}`,
+      errorType: "KbMatchInput" /* KbMatchInput */,
+      code: 400,
+      fault: "User" /* User */,
+      retriable: false,
+      reportToUser: true,
+      details: { reason }
+    });
+    this.reason = reason;
+  }
+  reason;
+};
+
+// src/commands/match/model.ts
+var import_zod11 = require("zod");
+var diffHunkSchema = import_zod11.z.object({
+  startLine: import_zod11.z.number().int().positive(),
+  endLine: import_zod11.z.number().int().positive(),
+  side: import_zod11.z.enum(["old", "new"]).optional()
+}).passthrough();
+var diffFileSchema = import_zod11.z.object({
+  filePath: import_zod11.z.string().min(1).describe("Repo-relative, spelled the way anchors are."),
+  hunks: import_zod11.z.array(diffHunkSchema)
+});
+var symbolRangeSchema = import_zod11.z.object({
+  file: import_zod11.z.string().min(1),
+  symbol: import_zod11.z.string().min(1),
+  startLine: import_zod11.z.number().int().positive(),
+  endLine: import_zod11.z.number().int().positive()
+});
+
+// src/commands/match/parse-unified-diff.ts
+var FILE_HEADER = /^diff --git (.+)$/;
+var HUNK = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
+var SIMILARITY = /^similarity index (\d+)%$/;
+var KNOWN_PREFIX = /^[ab]\//;
+function parseUnifiedDiff(patch, options = {}) {
+  const files = [];
+  let current;
+  let listed = false;
+  let shared;
+  let oldPath;
+  let rename4 = {};
+  let inHeader = false;
+  let added;
+  let removed;
+  const list = () => {
+    if (!current || listed) return;
+    files.push(current);
+    listed = true;
+  };
+  const open2 = (filePath) => {
+    current = { filePath, hunks: [], ...rename4 };
+    listed = false;
+  };
+  const amend = () => {
+    if (current) Object.assign(current, rename4);
+  };
+  const close = () => {
+    if (options.keepEmpty) list();
+    current = void 0;
+    listed = false;
+    added = void 0;
+    removed = void 0;
+  };
+  for (const raw of patch.split("\n")) {
+    const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+    const start = FILE_HEADER.exec(line);
+    if (start) {
+      close();
+      oldPath = void 0;
+      rename4 = {};
+      shared = sharedHeaderPath(start[1]);
+      inHeader = true;
+      if (shared) open2(shared);
+      continue;
+    }
+    if (inHeader) {
+      const similarity = SIMILARITY.exec(line);
+      if (similarity) {
+        rename4.similarity = Number(similarity[1]);
+        amend();
+        continue;
+      }
+      if (line.startsWith("rename from ")) {
+        rename4.renamedFrom = unquote(line.slice(12).trim());
+        amend();
+        continue;
+      }
+      if (line.startsWith("rename to ")) {
+        open2(unquote(line.slice(10).trim()));
+        continue;
+      }
+      if (line.startsWith("--- ")) {
+        oldPath = sidePath(line.slice(4), shared);
+        continue;
+      }
+      if (line.startsWith("+++ ")) {
+        const path = sidePath(line.slice(4), shared) ?? oldPath;
+        if (path) open2(path);
+        else current = void 0;
+        continue;
+      }
+    }
+    const hunk = HUNK.exec(line);
+    if (!hunk) {
+      if (!options.withLines || inHeader) continue;
+      if (line.startsWith("+")) added?.lines?.push(line.slice(1));
+      else if (line.startsWith("-")) removed?.lines?.push(line.slice(1));
+      continue;
+    }
+    inHeader = false;
+    added = void 0;
+    removed = void 0;
+    if (!current) continue;
+    const [next, before] = hunksOf(hunk, options.withLines === true);
+    added = next;
+    removed = before;
+    list();
+    current.hunks.push(...before ? [next, before] : [next]);
+  }
+  close();
+  return files;
+}
+function hunksOf(hunk, withLines) {
+  const oldStart = Number(hunk[1]);
+  const oldCount = hunk[2] === void 0 ? 1 : Number(hunk[2]);
+  const newStart = Number(hunk[3]);
+  const newCount = hunk[4] === void 0 ? 1 : Number(hunk[4]);
+  const lines = withLines ? { lines: [] } : {};
+  const added = newCount === 0 ? { ...point(newStart), ...lines } : { startLine: newStart, endLine: newStart + newCount - 1, ...lines };
+  if (oldCount === 0) return [added];
+  return [
+    added,
+    {
+      startLine: oldStart,
+      endLine: oldStart + oldCount - 1,
+      side: "old",
+      ...withLines ? { lines: [] } : {}
+    }
+  ];
+}
+function point(start) {
+  const at2 = Math.max(1, start);
+  return { startLine: at2, endLine: at2 };
+}
+function sidePath(raw, shared) {
+  const text = unquote(raw.replace(/\t.*$/, "").trim());
+  if (text === "/dev/null") return void 0;
+  if (KNOWN_PREFIX.test(text)) return text.slice(2);
+  return shared ?? text;
+}
+function sharedHeaderPath(rest) {
+  const pair = splitHeaderPair(rest);
+  if (!pair || pair[0] === pair[1]) return void 0;
+  const from = unquote(pair[0]).split("/");
+  const to = unquote(pair[1]).split("/");
+  const shared = [];
+  while (from.length > 1 && to.length > 1 && from.at(-1) === to.at(-1)) {
+    shared.unshift(from.pop());
+    to.pop();
+  }
+  return shared.length ? shared.join("/") : void 0;
+}
+function splitHeaderPair(rest) {
+  if (rest.startsWith('"')) {
+    const end = endOfQuoted(rest);
+    if (end < 0 || rest[end + 1] !== " ") return void 0;
+    return [rest.slice(0, end + 1), rest.slice(end + 2)];
+  }
+  const mid = (rest.length - 1) / 2;
+  if (Number.isInteger(mid) && rest[mid] === " ") {
+    return [rest.slice(0, mid), rest.slice(mid + 1)];
+  }
+  const at2 = rest.indexOf(" ");
+  return at2 === -1 ? void 0 : [rest.slice(0, at2), rest.slice(at2 + 1)];
+}
+function endOfQuoted(text) {
+  for (let at2 = 1; at2 < text.length; at2 += 1) {
+    if (text[at2] === "\\") {
+      at2 += 1;
+      continue;
+    }
+    if (text[at2] === '"') return at2;
+  }
+  return -1;
+}
+var ESCAPES = {
+  a: 7,
+  b: 8,
+  f: 12,
+  n: 10,
+  r: 13,
+  t: 9,
+  v: 11,
+  '"': 34,
+  "\\": 92
+};
+var OCTAL = /^[0-7]{3}/;
+var utf8 = new TextEncoder();
+function unquote(text) {
+  if (text.length < 2 || !text.startsWith('"') || !text.endsWith('"')) {
+    return text;
+  }
+  const body = text.slice(1, -1);
+  const bytes = [];
+  for (let at2 = 0; at2 < body.length; ) {
+    const slash = body.indexOf("\\", at2);
+    if (slash < 0) {
+      bytes.push(...utf8.encode(body.slice(at2)));
+      break;
+    }
+    if (slash > at2) bytes.push(...utf8.encode(body.slice(at2, slash)));
+    const octal = OCTAL.exec(body.slice(slash + 1, slash + 4));
+    if (octal) {
+      bytes.push(Number.parseInt(octal[0], 8));
+      at2 = slash + 4;
+      continue;
+    }
+    const next = body[slash + 1];
+    if (next === void 0) {
+      bytes.push(ESCAPES["\\"]);
+      break;
+    }
+    const mapped = ESCAPES[next];
+    if (mapped === void 0) bytes.push(...utf8.encode(next));
+    else bytes.push(mapped);
+    at2 = slash + 2;
+  }
+  return new TextDecoder().decode(Uint8Array.from(bytes));
+}
+
+// src/commands/match/symbol-ranges.ts
+async function resolveSymbolRanges(repoRoot, files, records, offline = false) {
+  const changed = new Set(files.map((file) => strip(file.filePath)));
+  const wanted = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const record of records) {
+    for (const anchor of record.frontmatter.strauss_anchors ?? []) {
+      if (!anchor.symbol || anchor.repo) continue;
+      if (!changed.has(strip(anchor.file))) continue;
+      const key2 = `${strip(anchor.file)}#${anchor.symbol}`;
+      if (seen.has(key2)) continue;
+      seen.add(key2);
+      wanted.push(anchor);
+    }
+  }
+  if (!wanted.length) return [];
+  const paths = [...new Set(wanted.map((anchor) => anchor.file))];
+  const sources = await readAnchorFiles(paths, anchorFileReader(repoRoot));
+  const resolvers = defaultAnchorResolvers({ offline });
+  await prepareResolvers(resolvers, paths);
+  const ranges = [];
+  for (const anchor of wanted) {
+    const read = sources.get(anchor.file);
+    if (!read?.ok) continue;
+    const outcome = resolveAnchorSpan(read.source, anchor, resolvers);
+    if (!outcome.ok) continue;
+    ranges.push({
+      file: anchor.file,
+      symbol: anchor.symbol,
+      startLine: outcome.span.startLine,
+      endLine: outcome.span.endLine
+    });
+  }
+  return ranges;
+}
+function strip(path) {
+  return path.replace(/^\.\//, "");
+}
+
+// src/commands/match/command.ts
+var matchCommand = define({
+  name: "match",
+  tool: "kb_match",
+  usage: "match --git <base>..<head> | --stdin [--repo-root <path>] [--offline] [--include-non-current]",
+  description: "Which records sit on each changed hunk: the anchored records per file range, current first, each with its standing and the anchor that matched. kb_load hands over a whole base; this narrows a diff. Symbol ranges resolve from repoRoot when omitted; non-current records need includeNonCurrent.",
+  input: import_zod12.z.object({
+    bundlePath,
+    files: import_zod12.z.array(diffFileSchema).describe("The changed files, each with its post-change line ranges."),
+    symbolRanges: import_zod12.z.array(symbolRangeSchema).optional().describe(
+      "Symbol spans the caller already has. Resolved from repoRoot when omitted."
+    ),
+    repoRoot: REPO_ROOT,
+    offline: import_zod12.z.boolean().optional().describe(
+      "Resolve symbol ranges from what is already on disk, never fetching a grammar."
+    ),
+    includeNonCurrent: import_zod12.z.boolean().optional().describe(
+      "Return superseded, rejected and unsettled records too, each carrying its standing."
+    )
+  }),
+  fromArgv: async (argv, path, stdin) => {
+    const repoRoot = argvFlag(argv, "--repo-root");
+    const range = argvFlag(argv, "--git");
+    const base2 = {
+      bundlePath: path,
+      ...repoRoot !== void 0 ? { repoRoot } : {},
+      ...argv.includes("--offline") ? { offline: true } : {},
+      ...argv.includes("--include-non-current") ? { includeNonCurrent: true } : {}
+    };
+    if (range !== void 0) {
+      const diff = await readRangeDiff(repoRoot ?? process.cwd(), range);
+      if (!diff.ok) {
+        throw new KbMatchInputError(`--git ${range} ${REFUSED[diff.reason]}`);
+      }
+      return { ...base2, files: parseUnifiedDiff(diff.text) };
+    }
+    if (!argv.includes("--stdin")) {
+      throw new KbMatchInputError(
+        "pass --git <base>..<head>, or --stdin with { files } as JSON"
+      );
+    }
+    return { ...base2, ...fromStdin(await stdin()) };
+  },
+  run: async ({ store }, {
+    bundlePath: path,
+    files,
+    symbolRanges,
+    repoRoot,
+    offline,
+    includeNonCurrent
+  }) => {
+    const records = await store.list(path);
+    const ranges = symbolRanges ?? await resolveSymbolRanges(
+      repoRoot ?? process.cwd(),
+      files,
+      records,
+      offline === true
+    );
+    const index2 = symbolRangeIndex(ranges);
+    return matchToDiff(files, records, { symbolRanges: ranges }).flatMap(
+      (match) => project(match, index2, includeNonCurrent === true)
+    );
+  }
+});
+var REFUSED = {
+  "bad-range": "is not a range git could read here \u2014 both halves of <base>..<head> are required",
+  "too-large": "diffs to a patch past the output cap \u2014 narrow the range",
+  timeout: "took longer to diff than the runner allows \u2014 narrow the range",
+  "git-missing": "needs git on PATH, and there is none"
+};
+function fromStdin(text) {
+  let payload;
+  try {
+    payload = JSON.parse(text);
+  } catch {
+    throw new KbMatchInputError("stdin is not JSON");
+  }
+  if (!Array.isArray(payload?.files)) {
+    throw new KbMatchInputError("stdin needs a files array");
+  }
+  return {
+    files: payload.files,
+    ...payload.symbolRanges !== void 0 ? { symbolRanges: payload.symbolRanges } : {}
+  };
+}
+function project(match, ranges, all) {
+  const kept = all ? match.records : match.records.filter((hit) => hit.standing === "current");
+  if (!kept.length) return [];
+  const placed = kept.map((hit) => ({
+    hit,
+    at: placeOnHunk(hit.record, match.filePath, match.hunk, ranges)
+  }));
+  return [
+    {
+      filePath: match.filePath,
+      hunk: match.hunk,
+      // Over the records returned, not the ones matched: a hunk holding only
+      // symbol-placed records is not `file` because a dropped one was.
+      precision: placed.every(({ at: at2 }) => at2.kind === "symbol") ? "symbol" : "file",
+      records: placed.map(({ hit, at: { anchor } }) => {
+        const { frontmatter } = hit.record;
+        return {
+          conceptId: hit.record.conceptId,
+          type: frontmatter.type,
+          title: frontmatter.title ?? null,
+          standing: hit.standing,
+          status: frontmatter.strauss_status,
+          supersededBy: hit.heads.map((head) => head.conceptId),
+          ...frontmatter.strauss_materiality ? { materiality: frontmatter.strauss_materiality } : {},
+          ...frontmatter.strauss_confidence ? { confidence: frontmatter.strauss_confidence } : {},
+          ...frontmatter.tags?.length ? { tags: frontmatter.tags } : {},
+          ...anchor ? { anchor } : {}
+        };
+      })
+    }
+  ];
+}
+
+// src/commands/classify.ts
+var classifyFileSchema = diffFileSchema.extend({
+  hunks: import_zod13.z.array(
+    diffHunkSchema.extend({ lines: import_zod13.z.array(import_zod13.z.string()).optional() })
+  ),
+  renamedFrom: import_zod13.z.string().min(1).optional().describe("Where `git diff -M` says the path came from."),
+  similarity: import_zod13.z.number().min(0).max(100).optional()
+});
+var classifyCommand = define({
+  name: "classify",
+  tool: "kb_classify",
+  usage: "classify --git <base>..<head> | --stdin [--repo-root <path>] [--offline]",
+  description: "What kind of change each file carries: test, config, ci, docs, lockfile, generated, boilerplate, rename or source, with the rule that decided it. Derived from the diff and never stored; a `review:generated`, `review:boilerplate` or `review:move` fact anchored on a file overrides the heuristic. kb_match says what sits on a hunk; this says whether to read it.",
+  input: import_zod13.z.object({
+    bundlePath,
+    files: import_zod13.z.array(classifyFileSchema).describe("The changed files, each with its line ranges."),
+    repoRoot: REPO_ROOT,
+    offline: import_zod13.z.boolean().optional().describe(
+      "Resolve symbol ranges from what is already on disk, never fetching a grammar."
+    )
+  }),
+  fromArgv: async (argv, path, stdin) => {
+    const repoRoot = argvFlag(argv, "--repo-root");
+    const range = argvFlag(argv, "--git");
+    const base2 = {
+      bundlePath: path,
+      ...repoRoot !== void 0 ? { repoRoot } : {},
+      ...argv.includes("--offline") ? { offline: true } : {}
+    };
+    if (range !== void 0) {
+      const diff = await readRangeDiff(repoRoot ?? process.cwd(), range);
+      if (!diff.ok) {
+        throw new KbClassifyInputError(
+          `--git ${range} ${REFUSED2[diff.reason]}`
+        );
+      }
+      return {
+        ...base2,
+        files: parseUnifiedDiff(diff.text, {
+          keepEmpty: true,
+          withLines: true
+        })
+      };
+    }
+    if (!argv.includes("--stdin")) {
+      throw new KbClassifyInputError(
+        "pass --git <base>..<head>, or --stdin with { files } as JSON"
+      );
+    }
+    return { ...base2, files: fromStdin2(await stdin()) };
+  },
+  run: async ({ store }, { bundlePath: path, files, repoRoot, offline }) => {
+    const records = await store.list(path);
+    const root = repoRoot ?? process.cwd();
+    const withHeaders = await mapLimit2(files, READERS, async (file) => ({
+      ...file,
+      header: await header(root, file)
+    }));
+    const symbolRanges = await resolveSymbolRanges(
+      root,
+      files,
+      records,
+      offline === true
+    );
+    return { files: classifyDiff(withHeaders, { records, symbolRanges }) };
+  },
+  render: (result) => renderClassify(result)
+});
+var HEADER_BYTES = 65536;
+var READERS = 16;
+async function header(root, file) {
+  if (!filePathIsSafe(file.filePath)) return void 0;
+  let handle;
+  try {
+    handle = await (0, import_promises7.open)((0, import_node_path10.join)(root, file.filePath), "r");
+    const buffer = import_node_buffer.Buffer.alloc(HEADER_BYTES);
+    const { bytesRead } = await handle.read(buffer, 0, HEADER_BYTES, 0);
+    return buffer.toString("utf8", 0, bytesRead).split("\n").slice(0, HEADER_LINES);
+  } catch {
+    return void 0;
+  } finally {
+    await handle?.close();
+  }
+}
+async function mapLimit2(items, limit, run) {
+  const out = Array.from({ length: items.length });
+  let next = 0;
+  const worker = async () => {
+    while (next < items.length) {
+      const at2 = next;
+      next += 1;
+      out[at2] = await run(items[at2]);
+    }
+  };
+  await Promise.all(
+    Array.from({ length: Math.min(limit, items.length) }, () => worker())
+  );
+  return out;
+}
+var REFUSED2 = {
+  "bad-range": "is not a range git could read here \u2014 both halves of <base>..<head> are required",
+  "too-large": "diffs to a patch past the output cap \u2014 narrow the range",
+  timeout: "took longer to diff than the runner allows \u2014 narrow the range",
+  "git-missing": "needs git on PATH, and there is none"
+};
+function fromStdin2(text) {
+  let payload;
+  try {
+    payload = JSON.parse(text);
+  } catch {
+    throw new KbClassifyInputError("stdin is not JSON");
+  }
+  if (!Array.isArray(payload?.files)) {
+    throw new KbClassifyInputError("stdin needs a files array");
+  }
+  return payload.files;
+}
+function renderClassify(result) {
+  const width2 = Math.max(
+    0,
+    ...result.files.map((file) => file.class.length)
+  );
+  return result.files.map(
+    (file) => `${file.class.padEnd(width2)}  ${file.filePath}  (${file.reason})`
+  ).join("\n");
+}
+
+// src/commands/context.ts
+var import_zod14 = require("zod");
+
+// src/kb-context.ts
+var import_promises8 = require("fs/promises");
+
+// src/kb-index.ts
+var INDEX_FILE = "INDEX.md";
+var HEADING = "# KB Index";
+function renderIndex(records) {
+  const lines = [...records].sort((left, right) => left.conceptId.localeCompare(right.conceptId)).map(renderIndexLine);
+  return `${HEADING}
+
+${lines.join("\n")}
+`;
+}
+function renderIndexLine(record) {
+  const { frontmatter: fm } = record;
+  const parts = [fm.type, fm.strauss_status];
+  if (fm.tags?.length) parts.push(`tags: ${fm.tags.join(", ")}`);
+  if (fm.description) parts.push(fm.description);
+  return `- [${fm.title ?? record.conceptId}](${record.conceptId}.md) \u2014 ${parts.join(" \xB7 ")}`;
+}
+function indexIsStale(stored, expected) {
+  return stored !== expected;
+}
+
+// src/kb-context.ts
+var HEADING2 = "## Knowledge bases (pinned)";
+var DEFAULT_CONTEXT_BUDGET = 4e3;
+var CONTEXT_PROFILES = {
+  "session-start": { fullUnderTokens: 1500 },
+  compact: { budgetTokens: 2500 },
+  turn: { budgetTokens: 2500 }
+};
+function approxTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function preamble() {
+  return [
+    HEADING2,
+    "",
+    "What follows is an index of this workspace's pinned knowledge bases \u2014",
+    "concept ids, titles and standing only. The record bodies are NOT in this",
+    "context.",
+    "",
+    "Consult records only through the strauss-kb MCP tools: `kb_load` (the",
+    "preferred first call), `kb_query`, and `kb_trace`, passing the",
+    "`bundlePath` listed with each base. Do not read record files directly:",
+    "a raw file read bypasses supersession resolution, and a superseded or",
+    "rejected record file reads exactly like a current one \u2014 only the store",
+    "resolves chains and standing.",
+    "",
+    "KB content loaded earlier in a long session may have been compacted",
+    "away. Before answering a question one of these bases governs, load it",
+    "again at the point of use \u2014 reloading a small base costs a few thousand",
+    "tokens."
+  ].join("\n");
+}
+async function renderBase(store, path, absolutePath, fullUnderTokens, pinMode, budgetTokens, excludeTags) {
+  const bundle = await store.list(absolutePath);
+  if (bundle.length === 0) {
+    return {
+      path,
+      absolutePath,
+      mode: "empty",
+      body: "No readable records yet \u2014 pinned ahead of being populated."
+    };
+  }
+  const fullCap = pinMode === "full" ? budgetTokens : pinMode === "index" ? 0 : fullUnderTokens;
+  let degradedFrom;
+  if (fullCap > 0) {
+    const full = await store.load(absolutePath, {
+      budgetTokens: fullCap,
+      excludeTags
+    });
+    if (!full.loaded && pinMode === "full") {
+      degradedFrom = { approxTokens: full.approxTokens };
+    }
+    if (full.loaded) {
+      const records = full.records.map(
+        (hit) => [
+          `#### ${hit.record.conceptId} \u2014 ${hit.record.frontmatter.title ?? "(untitled)"} (${hit.standing})`,
+          "",
+          hit.record.body.trim()
+        ].join("\n")
+      );
+      const superseded2 = full.superseded.map(
+        (entry) => `- \`${entry.conceptId}\` \u2192 superseded by ${entry.supersededBy.map((id) => `\`${id}\``).join(", ") || "(missing replacement)"}`
+      );
+      return {
+        path,
+        absolutePath,
+        mode: "full",
+        body: [
+          ...records,
+          ...superseded2.length ? [
+            "#### Superseded (bodies withheld \u2014 kb_trace reaches them)",
+            ...superseded2
+          ] : []
+        ].join("\n\n")
+      };
+    }
+  }
+  const adjudicated = adjudicate(bundle, bundle).filter(
+    (hit) => matchesTags(hit.record, { excludeTags })
+  );
+  const lines = adjudicated.filter((hit) => hit.standing !== "superseded").map((hit) => renderIndexLine(hit.record));
+  const superseded = adjudicated.filter((hit) => hit.standing === "superseded").map(
+    (hit) => `- \`${hit.record.conceptId}\` \u2192 superseded by ${hit.heads.map((head) => `\`${head.conceptId}\``).join(", ") || "(missing replacement)"}`
+  );
+  return {
+    path,
+    absolutePath,
+    mode: "index",
+    body: [...lines, ...superseded].join("\n"),
+    ...degradedFrom ? { degradedFrom } : {}
+  };
+}
+async function buildContext(store, workspaceDir, options = {}) {
+  const builtin = options.profile ? CONTEXT_PROFILES[options.profile] ?? {} : {};
+  let budgetTokens = options.budgetTokens ?? builtin.budgetTokens ?? DEFAULT_CONTEXT_BUDGET;
+  let fullUnderTokens = options.fullUnderTokens ?? builtin.fullUnderTokens ?? 0;
+  const merged = await readMergedPins(workspaceDir);
+  const fromManifest = mergedContextBudgets(merged, options.profile);
+  budgetTokens = options.budgetTokens ?? fromManifest.budgetTokens ?? builtin.budgetTokens ?? DEFAULT_CONTEXT_BUDGET;
+  fullUnderTokens = options.fullUnderTokens ?? fromManifest.fullUnderTokens ?? builtin.fullUnderTokens ?? 0;
+  const excludeTags = options.excludeTags ?? fromManifest.excludeTags ?? builtin.excludeTags ?? [];
+  const pins = merged.pins.filter(
+    (pin) => !pin.profiles?.length || !options.profile || pin.profiles.includes(options.profile)
+  );
+  if (pins.length === 0) {
+    return {
+      block: "",
+      refused: false,
+      approxTokens: 0,
+      budgetTokens,
+      bases: []
+    };
+  }
+  const sections = await Promise.all(
+    pins.map(async (pin) => ({
+      section: await renderBase(
+        store,
+        pin.path,
+        pin.absolutePath,
+        fullUnderTokens,
+        pin.mode,
+        budgetTokens,
+        excludeTags
+      ),
+      frozen: pin.frozen === true
+    }))
+  );
+  const modeLabel = {
+    index: "index only \u2014 record bodies are not here",
+    full: "full records \u2014 this base arrives whole",
+    empty: "empty"
+  };
+  for (const { section } of sections) {
+    if (section.degradedFrom) {
+      options.warn?.({
+        operation: "kb.context.full-pin-degraded",
+        path: section.path,
+        approxTokens: section.degradedFrom.approxTokens,
+        budgetTokens
+      });
+    }
   }
-  const rendered = unifiedDiff(found.oldText, found.newText ?? "", {
-    maxLines
+  const rendered = sections.map(({ section, frozen }) => {
+    const label = section.degradedFrom ? `index only \u2014 pinned \`mode: full\`, but its ~${section.degradedFrom.approxTokens} tokens exceed this block's ${budgetTokens}-token budget; kb_load it directly (load's budget is separate), or raise this profile's budget` : modeLabel[section.mode];
+    return [
+      `### ${section.path} (${label}${frozen ? " \xB7 frozen, read-only" : ""})`,
+      "",
+      `bundlePath: \`${section.absolutePath}\``,
+      "",
+      section.body
+    ].join("\n");
   });
-  return {
-    ...base2,
-    diff: {
-      status: "ok",
-      source: found.oldOrigin.kind,
-      ref: found.oldOrigin.ref,
-      unified: rendered.text,
-      added: rendered.added,
-      removed: rendered.removed,
-      truncated: rendered.truncated
+  const block = [preamble(), "", rendered.join("\n\n"), ""].join("\n");
+  const bases = sections.map(({ section }) => ({
+    path: section.path,
+    absolutePath: section.absolutePath,
+    approxTokens: approxTokens(section.body)
+  }));
+  const total = approxTokens(block);
+  if (total > budgetTokens) {
+    options.warn?.({
+      operation: "kb.context.refused",
+      approxTokens: total,
+      budgetTokens,
+      bases: bases.map((base2) => base2.path)
+    });
+    const refusal = [
+      HEADING2,
+      "",
+      `The pinned index runs to ~${total} tokens, past the ${budgetTokens}-token`,
+      "budget, and was not emitted \u2014 a truncated index is indistinguishable",
+      "from a complete one. The pinned bases:",
+      "",
+      ...bases.map(
+        (base2) => `- ${base2.path} \u2014 ~${base2.approxTokens} tokens (bundlePath: \`${base2.absolutePath}\`)`
+      ),
+      "",
+      "For the question at hand, read what you need now \u2014 `kb_load` a base",
+      "(its own budget is separate), or `kb_index` for one base's shape.",
+      "",
+      "To bring this block back under budget, in order of preference:",
+      "- supersede or resolve stale records \u2014 the base shrinks, the knowledge keeps",
+      "- force a large base to index lines: `strauss-kb pin <path> --mode index`",
+      "- scope a pin to the profiles that need it: `strauss-kb pin <path> --profiles session-start`",
+      "- raise this profile's budget under `context` in .strauss/kb-pins.json",
+      "- unpin what no session actually needs",
+      ""
+    ].join("\n");
+    return {
+      block: refusal,
+      refused: true,
+      approxTokens: total,
+      budgetTokens,
+      bases
+    };
+  }
+  return { block, refused: false, approxTokens: total, budgetTokens, bases };
+}
+function toHookJson(block, event) {
+  return JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: event,
+      additionalContext: block
     }
-  };
+  });
 }
-function claimOf(record) {
-  const type = record.frontmatter.type;
-  const section = isKbRecordType(type) ? RECORD_TYPES[type].sections[0] : void 0;
-  if (!section) return null;
-  const lines = record.body.replace(/\r\n/g, "\n").split("\n");
-  const start = lines.findIndex(
-    (line) => line.trim().toLowerCase() === `## ${section}`.toLowerCase()
+var CONTEXT_BEGIN = "<!-- strauss-kb:begin -->";
+var CONTEXT_END = "<!-- strauss-kb:end -->";
+async function syncInstructions(file, block) {
+  const existing = await (0, import_promises8.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_promises8.writeFile)(file, `${region}
+`, "utf8");
+    return { file, action: "created" };
+  }
+  const begin = existing.indexOf(CONTEXT_BEGIN);
+  const end = existing.indexOf(CONTEXT_END);
+  if (begin !== -1 && end !== -1 && end >= begin) {
+    const before = existing.slice(0, begin);
+    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_promises8.writeFile)(file, next, "utf8");
+    return { file, action: region ? "replaced" : "removed" };
+  }
+  if (!region) return { file, action: "unchanged" };
+  await (0, import_promises8.writeFile)(
+    file,
+    `${existing.replace(/\n*$/, "\n\n")}${region}
+`,
+    "utf8"
   );
-  if (start < 0) return null;
-  const rest = lines.slice(start + 1);
-  const end = rest.findIndex((line) => line.startsWith("## "));
-  const text = (end < 0 ? rest : rest.slice(0, end)).join("\n").trim();
-  return text ? { section, text } : null;
+  return { file, action: "appended" };
 }
 
+// src/commands/context.ts
+var contextCommand = define({
+  name: "context",
+  tool: "kb_context",
+  usage: "context [--profile NAME] [--budget N] [--full-under N] [--exclude-tag T]... [--format json] [--event NAME]",
+  description: "Index block of pinned bases (ids, titles, standing) for injection at context birth. Takes no bundlePath \u2014 reads the workspace pin manifests. Empty when nothing is pinned; refuses over budget rather than truncating. Budget precedence: flags, then the manifest `context[profile]` over `context.default`, then the built-in profile, then package defaults.",
+  input: import_zod14.z.object({
+    budgetTokens: import_zod14.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_zod14.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_zod14.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."
+    ),
+    excludeTags: import_zod14.z.array(import_zod14.z.string().min(1)).optional().describe(
+      "Frontmatter tags whose records stay out of the block. The base stays pinned and stays readable by tool; resolved like the budgets."
+    ),
+    format: import_zod14.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_zod14.z.string().optional().describe(
+      "hookEventName stamped into the JSON envelope. Only meaningful with format=json."
+    )
+  }),
+  fromArgv: (argv) => {
+    const budget = argvFlag(argv, "--budget");
+    const fullUnder = argvFlag(argv, "--full-under");
+    const profile = argvFlag(argv, "--profile");
+    const format = argvFlag(argv, "--format");
+    const event = argvFlag(argv, "--event");
+    const excludeTags = argvFlags(argv, "--exclude-tag");
+    return {
+      ...budget ? { budgetTokens: Number(budget) } : {},
+      ...fullUnder ? { fullUnderTokens: Number(fullUnder) } : {},
+      ...profile ? { profile } : {},
+      ...excludeTags.length ? { excludeTags } : {},
+      ...format ? { format } : {},
+      ...event ? { event } : {}
+    };
+  },
+  run: async ({ store }, { budgetTokens, fullUnderTokens, profile, excludeTags, format, event }) => {
+    const result = await buildContext(store, process.cwd(), {
+      ...budgetTokens ? { budgetTokens } : {},
+      ...fullUnderTokens ? { fullUnderTokens } : {},
+      ...profile ? { profile } : {},
+      ...excludeTags ? { excludeTags } : {},
+      // Degradations — a full pin that could not fit, a refused block — go
+      // to stderr as well as into the block itself: stderr is diagnostics on
+      // both surfaces (hooks discard it, MCP logs it), so an operator can
+      // see budget pressure without reading injected context.
+      warn: (entry) => process.stderr.write(`${JSON.stringify(entry)}
+`)
+    });
+    if (!result.block) return "";
+    return format === "json" ? toHookJson(result.block, event ?? "SessionStart") : result.block;
+  }
+});
+
+// src/commands/doctor.ts
+var import_zod16 = require("zod");
+
 // src/kb-edges.ts
 var KB_EDGE_KINDS = [
   "body-link",
@@ -3975,6 +5076,34 @@ function validateBundle(records) {
       }
     }
     for (const anchor of fm.strauss_anchors ?? []) {
+      if (anchor.span && anchor.symbol) {
+        report(
+          "anchor_span",
+          conceptId2,
+          `anchor ${anchor.file} names both a symbol and a span \u2014 one or the other`
+        );
+      }
+      if (anchor.span && anchor.span.end < anchor.span.start) {
+        report(
+          "anchor_span",
+          conceptId2,
+          `anchor ${anchor.file} span ${anchor.span.start}-${anchor.span.end} ends before it starts`
+        );
+      }
+      if (anchor.span && anchor.hash_kind === "ast") {
+        report(
+          "anchor_span",
+          conceptId2,
+          `anchor ${anchor.file} is a span with hash_kind: "ast" \u2014 a span is hashed raw`
+        );
+      }
+      if (anchor.side === "old" && !anchor.ref) {
+        report(
+          "anchor_side",
+          conceptId2,
+          `anchor ${anchor.file} is side: "old" with no ref`
+        );
+      }
       if (anchor.repo && !isCanonicalRepoUrl(anchor.repo)) {
         report(
           "anchor_repo",
@@ -4010,14 +5139,19 @@ var DAY_MS = 864e5;
 function anchorResolverCounts(bundle) {
   let treeSitter = 0;
   let regex = 0;
+  let span2 = 0;
+  let oldSide = 0;
   for (const record of bundle) {
     for (const anchor of record.frontmatter.strauss_anchors ?? []) {
-      if (!anchor.hash || !anchor.symbol) continue;
-      if (anchor.resolver === "tree-sitter") treeSitter += 1;
+      if (!anchor.hash) continue;
+      if (anchor.side === "old") oldSide += 1;
+      if (anchor.span) span2 += 1;
+      else if (!anchor.symbol) continue;
+      else if (anchor.resolver === "tree-sitter") treeSitter += 1;
       else regex += 1;
     }
   }
-  return { total: treeSitter + regex, treeSitter, regex };
+  return { total: treeSitter + regex + span2, treeSitter, regex, span: span2, oldSide };
 }
 function doctor(bundle, options = {}) {
   const thresholds = {
@@ -4027,7 +5161,7 @@ function doctor(bundle, options = {}) {
   };
   const now = options.now ?? /* @__PURE__ */ new Date();
   const adjudicated = adjudicate(bundle, bundle, now, options.anchorDrift);
-  const standings = new Map(
+  const standings2 = new Map(
     adjudicated.map((hit) => [hit.record.conceptId, hit.standing])
   );
   const inForce = adjudicated.filter(
@@ -4040,7 +5174,7 @@ 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, standings2)),
     group("drifted", drifted(inForce)),
     group("unchecked", unchecked(inForce))
   ];
@@ -4163,9 +5297,9 @@ function brokenSupersession(bundle, adjudicated) {
   const findings = [];
   const seen = /* @__PURE__ */ new Set();
   const add = (record, note) => {
-    const key = `${record.conceptId}\0${note}`;
-    if (seen.has(key)) return;
-    seen.add(key);
+    const key2 = `${record.conceptId}\0${note}`;
+    if (seen.has(key2)) return;
+    seen.add(key2);
     findings.push(finding(record, note));
   };
   for (const problem of validateBundle(bundle)) {
@@ -4206,14 +5340,14 @@ function brokenSupersession(bundle, adjudicated) {
     (left, right) => left.conceptId.localeCompare(right.conceptId)
   );
 }
-function supersededButCited(bundle, standings) {
+function supersededButCited(bundle, standings2) {
   const byId = new Map(bundle.map((record) => [record.conceptId, record]));
   const findings = [];
   for (const record of bundle) {
-    const standing = standings.get(record.conceptId);
+    const standing = standings2.get(record.conceptId);
     if (standing === "superseded" || standing === "rejected") continue;
     for (const target of edgeNeighbours(record, bundle, "body-link")) {
-      const targetStanding = standings.get(target.conceptId);
+      const targetStanding = standings2.get(target.conceptId);
       if (targetStanding !== "superseded" && targetStanding !== "rejected") {
         continue;
       }
@@ -4304,17 +5438,17 @@ function ageInDays(record, now) {
 }
 
 // src/commands/reassess.ts
-var import_zod12 = require("zod");
+var import_zod15 = require("zod");
 var reassessCommand = define({
   name: "reassess",
   tool: "kb_reassess",
   usage: "reassess <concept-id> [--repo-root <path>] [--with-diff]",
   description: "One drifted record, as something to judge: its claim, each anchor's drift class, the old-vs-new span diff, and the records that depend on it. Formatting-only drift is dropped. Empty when there is nothing to reassess. Writes: relocates moved anchors, keeping their hash; never verifies, supersedes, or changes standing.",
-  input: import_zod12.z.object({
+  input: import_zod15.z.object({
     bundlePath,
     conceptId,
     repoRoot: REPO_ROOT,
-    withDiff: import_zod12.z.boolean().optional().describe(
+    withDiff: import_zod15.z.boolean().optional().describe(
       "Recover each anchor's committed span and render the diff. Reads git history."
     )
   }),
@@ -4357,7 +5491,10 @@ var reassessCommand = define({
         relocated.set(found.anchor, {
           ...found.anchor,
           file: to.file,
-          ...to.symbol ? { symbol: to.symbol } : {}
+          ...to.symbol ? { symbol: to.symbol } : {},
+          // A span is the anchor's whole address, so relocating it means
+          // moving the line range the same code now occupies.
+          ...found.anchor.span ? { span: { start: to.startLine, end: to.endLine } } : {}
         });
         rebaselined.push({
           file: found.anchor.file,
@@ -4456,13 +5593,13 @@ function at(file, symbol) {
 }
 
 // src/commands/doctor.ts
-var days = (what, fallback) => import_zod13.z.number().int().positive().optional().describe(`${what} Defaults to ${fallback}.`);
+var days = (what, fallback) => import_zod16.z.number().int().positive().optional().describe(`${what} Defaults to ${fallback}.`);
 var doctorCommand = define({
   name: "doctor",
   tool: "kb_doctor",
   usage: "doctor [--expiring-days N] [--unverified-days N] [--aging-days N] [--repo-root PATH] [--offline] [--strict] [--drifted [--with-diff]]",
   description: "Read-only health sweep: expired, expiring, unverified, aging, orphaned, broken-supersession, superseded-but-cited, drifted and unchecked anchors. Every group is reported even when empty; nothing is written or re-stamped. `drifted` narrows it to a reassessment packet per drifted record, `with_diff` adding each anchor's old-vs-new span.",
-  input: import_zod13.z.object({
+  input: import_zod16.z.object({
     bundlePath,
     repoRoot: REPO_ROOT,
     expiringDays: days(
@@ -4477,16 +5614,16 @@ var doctorCommand = define({
       "How long a record may stay `open` or `proposed` before `aging` reports it, in days.",
       DEFAULT_AGING_DAYS
     ),
-    offline: import_zod13.z.boolean().optional().describe(
+    offline: import_zod16.z.boolean().optional().describe(
       "Read foreign anchors from the local repo cache only, never fetching."
     ),
-    strict: import_zod13.z.boolean().optional().describe(
+    strict: import_zod16.z.boolean().optional().describe(
       "Turn an expired record into a non-zero exit for the CLI. No effect on the report itself."
     ),
-    drifted: import_zod13.z.boolean().optional().describe(
+    drifted: import_zod16.z.boolean().optional().describe(
       "Report only drift, as a reassessment packet per record: claim, per-anchor class, and what depends on it."
     ),
-    withDiff: import_zod13.z.boolean().optional().describe(
+    withDiff: import_zod16.z.boolean().optional().describe(
       "With `drifted`: recover each anchor's committed span and render the old-vs-new diff. Reads git history."
     )
   }),
@@ -4542,7 +5679,7 @@ var doctorCommand = define({
         ...hints.length ? { hints } : {}
       };
     }
-    const standings = new Map(
+    const standings2 = new Map(
       adjudicate(records, records, new Date(checkedAt)).map((hit) => [
         hit.record.conceptId,
         hit.standing
@@ -4556,7 +5693,7 @@ var doctorCommand = define({
         (entry) => entry.conceptId === found.conceptId
       );
       if (!record) continue;
-      const standing = standings.get(record.conceptId);
+      const standing = standings2.get(record.conceptId);
       const built = await reassessPacket(
         repoRoot ?? process.cwd(),
         record,
@@ -4593,15 +5730,16 @@ var doctorCommand = define({
 });
 function render2(result) {
   if (result.packets) return renderPackets(result);
-  const { thresholds } = result;
+  const { thresholds, anchorResolvers: counts } = result;
   const lines = [
     `# KB Doctor \u2014 ${result.bundlePath}`,
     `records: ${result.recordCount}`,
     `thresholds: expiring within ${thresholds.expiringDays}d, unverified over ${thresholds.unverifiedDays}d, aging over ${thresholds.agingDays}d`,
     `checked: ${result.checkedAt}`,
-    ...result.anchorResolvers.total ? [
-      `anchors: ${result.anchorResolvers.total} hashed \u2014 ${result.anchorResolvers.treeSitter} tree-sitter, ${result.anchorResolvers.regex} regex`
-    ] : [],
+    ...counts.total ? [anchorLine(counts)] : [],
+    // Its own line: an old-side anchor may name a whole file, which no
+    // resolver bucket and no `total` counts.
+    ...counts.oldSide ? [`old-side anchors: ${counts.oldSide}`] : [],
     ""
   ];
   const width2 = Math.max(...result.groups.map((group2) => group2.check.length));
@@ -4626,6 +5764,14 @@ function render2(result) {
   );
   return lines.join("\n");
 }
+function anchorLine(counts) {
+  const parts = [
+    `${counts.treeSitter} tree-sitter`,
+    `${counts.regex} regex`,
+    ...counts.span ? [`${counts.span} span`] : []
+  ];
+  return `anchors: ${counts.total} hashed \u2014 ${parts.join(", ")}`;
+}
 function renderPackets(result) {
   const packets = result.packets ?? [];
   const lines = [
@@ -4638,33 +5784,168 @@ function renderPackets(result) {
       `moved, rebaseline with \`kb_reassess\`: ${result.rebaselinable.join(", ")}`
     );
   }
-  for (const packet of packets) {
-    lines.push(
-      renderReassess({
-        conceptId: packet.conceptId,
-        packet,
-        rebaselined: [],
-        cosmetic: 0
-      })
-    );
+  for (const packet of packets) {
+    lines.push(
+      renderReassess({
+        conceptId: packet.conceptId,
+        packet,
+        rebaselined: [],
+        cosmetic: 0
+      })
+    );
+  }
+  return lines.join("\n");
+}
+
+// src/commands/export.ts
+var import_promises9 = require("fs/promises");
+var import_node_path11 = require("path");
+var import_zod17 = require("zod");
+var NUMBERED = /^(\d{4})-(.+)\.md$/;
+var MARKER = "<!-- strauss-kb export: ";
+var exportCommand = define({
+  name: "export",
+  tool: "kb_export",
+  usage: "export --format madr --to <dir>",
+  description: "Write the base's decisions out as numbered MADR files, one per decision, for a repository that keeps ADRs of its own. Numbering is by slug, so a re-run rewrites its own files in place. A superseded decision is exported with what replaced it.",
+  input: import_zod17.z.object({
+    bundlePath,
+    format: import_zod17.z.enum(["madr"]).describe("Output layout. `madr` is the only one so far."),
+    to: import_zod17.z.string().min(1).describe("Directory the ADR files are written into.")
+  }),
+  fromArgv: (argv, path) => ({
+    bundlePath: path,
+    format: argvFlag(argv, "--format"),
+    to: argvFlag(argv, "--to")
+  }),
+  run: async ({ store }, { bundlePath: path, to }) => {
+    const bundle = await store.list(path);
+    const decisions = selectDecisions(bundle).sort(
+      (left, right) => left.conceptId.localeCompare(right.conceptId)
+    );
+    const adjudicated = new Map(
+      adjudicate(decisions, bundle).map((hit) => [hit.record.conceptId, hit])
+    );
+    await (0, import_promises9.mkdir)(to, { recursive: true });
+    const taken = await existingFiles(to);
+    let next = Math.max(0, ...[...taken.values()].map((row) => row.number)) + 1;
+    const exported = [];
+    const foreign = [];
+    for (const record of decisions) {
+      const slug = record.conceptId.slice(record.conceptId.indexOf(".") + 1);
+      const held = taken.get(slug);
+      if (held && !held.ours) {
+        foreign.push({ conceptId: record.conceptId, file: held.file });
+        continue;
+      }
+      const number = held?.number ?? next++;
+      const file = `${String(number).padStart(4, "0")}-${slug}.md`;
+      const status = statusLine(adjudicated.get(record.conceptId));
+      await publish((0, import_node_path11.join)(to, file), renderMadr(record, status));
+      exported.push({ conceptId: record.conceptId, file, status });
+    }
+    return { to, format: "madr", exported, foreign };
+  },
+  render: (result) => {
+    const { exported, foreign, to } = result;
+    return [
+      `Wrote ${exported.length} MADR file${exported.length === 1 ? "" : "s"} to ${to}.`,
+      ...exported.map(
+        (entry) => `- ${entry.file}  ${entry.conceptId} [${entry.status}]`
+      ),
+      ...foreign.map(
+        (entry) => `- skipped ${entry.conceptId}: ${entry.file} was not written by export`
+      )
+    ].join("\n");
+  }
+});
+async function publish(target, contents) {
+  const staging = `${target}.${process.pid}.tmp`;
+  await (0, import_promises9.writeFile)(staging, contents, "utf8");
+  try {
+    await (0, import_promises9.rename)(staging, target);
+  } catch (error) {
+    await (0, import_promises9.unlink)(staging).catch(() => void 0);
+    throw error;
+  }
+}
+async function existingFiles(to) {
+  const names = await (0, import_promises9.readdir)(to).catch(() => []);
+  const taken = /* @__PURE__ */ new Map();
+  for (const name of names.sort()) {
+    const [, number, slug] = NUMBERED.exec(name) ?? [];
+    if (!number || !slug) continue;
+    const text = await (0, import_promises9.readFile)((0, import_node_path11.join)(to, name), "utf8").catch(() => "");
+    taken.set(slug, {
+      file: name,
+      number: Number(number),
+      ours: text.includes(MARKER)
+    });
   }
-  return lines.join("\n");
+  return taken;
+}
+function statusLine(hit) {
+  const status = hit?.record.frontmatter.strauss_status ?? "draft";
+  if (status !== "superseded") return status;
+  const by = (hit?.heads ?? []).map((head) => head.conceptId);
+  return by.length ? `superseded by ${by.join(", ")}` : "superseded";
+}
+function renderMadr(record, status) {
+  const sections = bodySections(record.body);
+  const blocks = [
+    `# ${record.frontmatter.title ?? record.conceptId}`,
+    "## Status",
+    status
+  ];
+  push(blocks, "Context and Problem Statement", record.frontmatter.description);
+  push(blocks, "Considered Options", sections.get("Rejected"));
+  push(blocks, "Decision Outcome", sections.get("Decision"));
+  push(blocks, "Consequences", sections.get("Impact"));
+  blocks.push(`${MARKER}${record.conceptId} -->`);
+  return `${blocks.join("\n\n")}
+`;
+}
+function push(blocks, heading, text) {
+  if (text?.trim()) blocks.push(`## ${heading}`, text.trim());
+}
+function bodySections(body) {
+  const generated = new RegExp(
+    `^(?:(?:${Object.values(LINK_RELS).map((spec) => spec.phrase).join("|")}) \\[[^\\]]+\\]\\([^)]+\\.md\\)\\.|\\[\\^[^\\]]+\\]: .*)$`
+  );
+  const sections = /* @__PURE__ */ new Map();
+  let heading = null;
+  let lines = [];
+  const flush = () => {
+    if (heading) sections.set(heading, lines.join("\n").trim());
+  };
+  for (const line of body.split("\n")) {
+    const match = /^## (.+?)\s*$/.exec(line);
+    if (match) {
+      flush();
+      heading = match[1] ?? null;
+      lines = [];
+    } else if (heading && !generated.test(line)) {
+      lines.push(line);
+    }
+  }
+  flush();
+  return sections;
 }
 
 // src/commands/impact.ts
-var import_zod14 = require("zod");
+var import_zod18 = require("zod");
 var impactCommand = define({
   name: "impact",
   tool: "kb_impact",
   usage: "impact <concept-id> [--depth N] [--rels a,b]",
   description: "What breaks if this record changes: its transitive set of dependants, each with its standing. Each rel declares which of its ends depends on the other, and the walk follows each rel in its own direction. Naming `related_to` or an unknown rel in `rels` is an error. kb_backlinks gives one flat hop.",
-  input: import_zod14.z.object({
+  input: import_zod18.z.object({
     bundlePath,
     conceptId,
-    depth: import_zod14.z.number().int().positive().optional().describe(
+    depth: import_zod18.z.number().int().positive().optional().describe(
       "Hops out from the record. Unbounded when omitted; a walk this cuts reports truncated: true."
     ),
-    rels: import_zod14.z.array(import_zod14.z.enum(KB_CAUSAL_LINK_RELS)).optional().describe(
+    rels: import_zod18.z.array(import_zod18.z.enum(KB_CAUSAL_LINK_RELS)).optional().describe(
       "Narrow which rels the walk follows. Defaults to every rel that carries a dependence \u2014 all but related_to."
     )
   }),
@@ -4685,15 +5966,15 @@ var impactCommand = define({
 });
 
 // src/commands/list.ts
-var import_zod15 = require("zod");
+var import_zod19 = require("zod");
 var listCommand = define({
   name: "list",
   tool: "kb_list",
   usage: "list [type] [--tag T]...",
   description: "Every record, optionally one type or tag. For enumerating; use kb_query for a question.",
-  input: import_zod15.z.object({
+  input: import_zod19.z.object({
     bundlePath,
-    type: import_zod15.z.enum(KB_RECORD_TYPES).optional(),
+    type: import_zod19.z.enum(KB_RECORD_TYPES).optional(),
     tags: TAGS
   }),
   fromArgv: (argv, path) => {
@@ -4717,17 +5998,17 @@ var listCommand = define({
 });
 
 // src/commands/load.ts
-var import_zod16 = require("zod");
+var import_zod20 = require("zod");
 var loadCommand = define({
   name: "load",
   tool: "kb_load",
   usage: "load [type] [--budget N | --all] [--repo-root PATH]",
   description: "Load the whole base, each record with its standing \u2014 call it first, at the point of use, since compaction drops it. Superseded records arrive as stubs; kb_trace has the history. Over budget it refuses: kb_catalog, then kb_pack, or narrow with `type`; `all` bypasses. Never read record files directly \u2014 only kb_* tools resolve supersession. `digest` stamps the base's content, so hooks know when to reload.",
-  input: import_zod16.z.object({
+  input: import_zod20.z.object({
     bundlePath,
-    type: import_zod16.z.enum(KB_RECORD_TYPES).optional(),
-    budgetTokens: import_zod16.z.number().int().positive().optional().describe("Approximate token ceiling. Defaults to 25000."),
-    all: import_zod16.z.boolean().optional().describe(
+    type: import_zod20.z.enum(KB_RECORD_TYPES).optional(),
+    budgetTokens: import_zod20.z.number().int().positive().optional().describe("Approximate token ceiling. Defaults to 25000."),
+    all: import_zod20.z.boolean().optional().describe(
       "Loads the entire base regardless of size, bypassing the token budget; mutually exclusive with budgetTokens."
     ),
     repoRoot: REPO_ROOT
@@ -4769,25 +6050,25 @@ var loadCommand = define({
 });
 
 // src/commands/log.ts
-var import_zod17 = require("zod");
+var import_zod21 = require("zod");
 var logCommand = define({
   name: "log",
   tool: "kb_log",
   usage: "log",
   description: "Who touched what, and when. Append-only; malformed lines are reported, never repaired.",
-  input: import_zod17.z.object({ bundlePath }),
+  input: import_zod21.z.object({ bundlePath }),
   fromArgv: (_argv, path) => ({ bundlePath: path }),
   run: ({ store }, { bundlePath: path }) => store.readLog(path)
 });
 
 // src/commands/no-decision.ts
-var import_zod18 = require("zod");
+var import_zod22 = require("zod");
 var noDecisionCommand = define({
   name: "no-decision",
   tool: "kb_no_decision",
   usage: "no-decision <reason...>",
   description: "Record in one sentence that a piece of work had nothing to decide. Idempotent.",
-  input: import_zod18.z.object({ bundlePath, reason: import_zod18.z.string().min(1) }),
+  input: import_zod22.z.object({ bundlePath, reason: import_zod22.z.string().min(1) }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
     reason: argv.slice(1).join(" ").trim()
@@ -4804,20 +6085,20 @@ var noDecisionCommand = define({
 });
 
 // src/commands/pack.ts
-var import_zod19 = require("zod");
+var import_zod23 = require("zod");
 var packCommand = define({
   name: "pack",
   tool: "kb_pack",
   usage: "pack <conceptId> [--hops N] [--max-nodes N] [--budget N]",
   description: "Bounded neighbourhood around one record: within `hops`, ranked, cut to `maxNodes`, with every cut record named under Excluded. Use when the base is over kb_load's budget and the work centres on a record you can name. Refuses over budget rather than truncating. Everything below the header is byte-stable across runs. Resolves supersession like kb_load.",
-  input: import_zod19.z.object({
+  input: import_zod23.z.object({
     bundlePath,
     conceptId,
-    hops: import_zod19.z.number().int().positive().optional().describe("How far from the root the walk may reach. Defaults to 2."),
-    maxNodes: import_zod19.z.number().int().positive().optional().describe(
+    hops: import_zod23.z.number().int().positive().optional().describe("How far from the root the walk may reach. Defaults to 2."),
+    maxNodes: import_zod23.z.number().int().positive().optional().describe(
       "How many records the pack may hold, root included. Defaults to 20."
     ),
-    budgetTokens: import_zod19.z.number().int().positive().optional().describe(
+    budgetTokens: import_zod23.z.number().int().positive().optional().describe(
       "Approximate token ceiling over what is actually emitted. Defaults to 25000."
     )
   }),
@@ -4904,22 +6185,22 @@ function warningLabel(warning) {
 }
 
 // src/commands/pin.ts
-var import_zod20 = require("zod");
+var import_zod24 = require("zod");
 var pinCommand = define({
   name: "pin",
   tool: "kb_pin",
   usage: "pin [bundle-path] [--mode full|index] [--profiles a,b] [--local|--user] [--frozen|--unfreeze]",
   description: "Pin a base into a workspace manifest so kb_context surfaces it. Layers, nearest wins: project `.strauss/kb-pins.json` (default), `--local` (personal, gitignored), `--user` (`~/.strauss`). Idempotent; `--mode full|index`, `--profiles`, `--frozen`/`--unfreeze` update only those fields. A path with no records pins with a warning. Never touches the base itself.",
-  input: import_zod20.z.object({
+  input: import_zod24.z.object({
     bundlePath,
-    mode: import_zod20.z.enum(["full", "index"]).optional().describe(
+    mode: import_zod24.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_zod20.z.array(import_zod20.z.string()).optional().describe("Context profiles this pin surfaces in. Absent: all of them."),
-    layer: import_zod20.z.enum(["project", "local", "user"]).optional().describe(
+    profiles: import_zod24.z.array(import_zod24.z.string()).optional().describe("Context profiles this pin surfaces in. Absent: all of them."),
+    layer: import_zod24.z.enum(["project", "local", "user"]).optional().describe(
       "Which manifest to write: project (committed, default), local (personal, gitignored), user (~/.strauss, every workspace)."
     ),
-    frozen: import_zod20.z.boolean().optional().describe(
+    frozen: import_zod24.z.boolean().optional().describe(
       "true: the base is concluded \u2014 writes against it refuse while pinned. false: lift a freeze."
     )
   }),
@@ -4948,29 +6229,440 @@ var pinCommand = define({
 });
 
 // src/commands/pins.ts
-var import_zod21 = require("zod");
+var import_zod25 = require("zod");
 var pinsCommand = define({
   name: "pins",
   tool: "kb_pins",
   usage: "pins",
   description: "Every pinned base across the manifest layers, with its layer and whether it resolves to records. Takes no bundlePath.",
-  input: import_zod21.z.object({}),
+  input: import_zod25.z.object({}),
   fromArgv: () => ({}),
   run: ({ store }) => listPins(store, process.cwd())
 });
 
+// src/commands/promote/command.ts
+var import_node_path12 = require("path");
+
+// src/commands/promote/carry.ts
+var PROMOTION_SOURCE_ID = "promoted";
+var CARRIED_STATUS = {
+  draft: "accepted",
+  proposed: "accepted",
+  accepted: "accepted",
+  open: "open",
+  resolved: "resolved",
+  rejected: "rejected",
+  superseded: "superseded"
+};
+function carry(record, promoted, source) {
+  const {
+    type: _type,
+    // Both name records in the source base, and supersession in the target is
+    // a separate question from whether this record belongs there at all.
+    strauss_supersedes: _supersedes,
+    strauss_superseded_by: _supersededBy,
+    // A check run against the source repository, which the target never saw.
+    verified: _verified,
+    ...rest
+  } = record.frontmatter;
+  const links = rest.strauss_links ?? [];
+  const kept = links.filter((link2) => promoted.has(link2.target));
+  const dropped = links.filter((link2) => !promoted.has(link2.target));
+  const tags = (rest.tags ?? []).filter((tag) => !isReviewTag(tag));
+  const frontmatter = {
+    ...rest,
+    strauss_status: CARRIED_STATUS[rest.strauss_status]
+  };
+  setOrDrop(frontmatter, "tags", tags);
+  setOrDrop(frontmatter, "strauss_links", kept);
+  let body = withoutLinkSentences(record.body, dropped);
+  if (source) {
+    frontmatter.sources = [
+      ...(rest.sources ?? []).filter(
+        (entry) => entry.id !== PROMOTION_SOURCE_ID
+      ),
+      { id: PROMOTION_SOURCE_ID, resource: source }
+    ];
+    body = `${stripFootnote(body).trimEnd()}
+
+[^${PROMOTION_SOURCE_ID}]: ${source}
+`;
+  }
+  return {
+    frontmatter,
+    body,
+    droppedLinks: dropped.map(({ target, rel }) => ({ target, rel }))
+  };
+}
+function isReviewTag(tag) {
+  return tag === "review" || tag.startsWith("review:");
+}
+function withoutLinkSentences(body, dropped) {
+  const sentences = new Set(
+    dropped.filter((link2) => isKbLinkRel(link2.rel)).map(
+      (link2) => `${LINK_RELS[link2.rel].phrase} [${link2.target}](${link2.target}.md).`
+    )
+  );
+  if (!sentences.size) return body;
+  return body.split("\n\n").filter((block) => !sentences.has(block.trim())).join("\n\n");
+}
+function stripFootnote(body) {
+  return body.split("\n").filter((line) => !line.startsWith(`[^${PROMOTION_SOURCE_ID}]: `)).join("\n");
+}
+function setOrDrop(frontmatter, key2, value) {
+  if (value.length) frontmatter[key2] = value;
+  else delete frontmatter[key2];
+}
+
+// src/kb-links/inbound.ts
+function inboundIndex(bundle) {
+  const byTarget = /* @__PURE__ */ new Map();
+  for (const record of bundle) {
+    for (const link2 of record.frontmatter.strauss_links ?? []) {
+      if (link2.target === record.conceptId) continue;
+      const edges = byTarget.get(link2.target) ?? [];
+      if (edges.some(
+        (edge) => edge.from === record.conceptId && edge.rel === link2.rel
+      )) {
+        continue;
+      }
+      edges.push({ from: record.conceptId, rel: link2.rel });
+      byTarget.set(link2.target, edges);
+    }
+  }
+  return byTarget;
+}
+
+// src/kb-links/backlinks.ts
+function backlinks(targetId, bundle) {
+  const byId = new Map(bundle.map((record) => [record.conceptId, record]));
+  if (!byId.has(targetId)) throw new KbRecordNotFoundError(targetId);
+  const standingOf = new Map(
+    adjudicate(bundle, bundle).map((hit) => [hit.record.conceptId, hit])
+  );
+  const rows = [];
+  for (const edge of inboundIndex(bundle).get(targetId) ?? []) {
+    const record = byId.get(edge.from);
+    if (!record) continue;
+    const hit = standingOf.get(edge.from);
+    rows.push({
+      ...edge,
+      title: record.frontmatter.title ?? null,
+      standing: hit?.standing ?? "unsettled",
+      warnings: hit?.warnings ?? []
+    });
+  }
+  return {
+    target: targetId,
+    backlinks: rows.sort(
+      (left, right) => left.from.localeCompare(right.from) || left.rel.localeCompare(right.rel)
+    )
+  };
+}
+
+// src/kb-links/impact.ts
+function impact(targetId, bundle, options = {}) {
+  const byId = new Map(bundle.map((record) => [record.conceptId, record]));
+  if (!byId.has(targetId)) throw new KbRecordNotFoundError(targetId);
+  const rels = resolveRels(options.rels);
+  const maxDepth = options.depth ?? Number.POSITIVE_INFINITY;
+  const inbound = inboundIndex(bundle);
+  const standingOf = new Map(
+    adjudicate(bundle, bundle).map((hit) => [hit.record.conceptId, hit])
+  );
+  const reached = /* @__PURE__ */ new Map();
+  const stopped = [];
+  let frontier = [targetId];
+  let depth = 0;
+  while (frontier.length && depth < maxDepth) {
+    depth += 1;
+    const next = [];
+    const consider = (dependantId, edge) => {
+      if (dependantId === targetId) return;
+      const existing = reached.get(dependantId);
+      if (existing) {
+        if (!hasEdge(existing.via, edge)) existing.via.push(edge);
+        return;
+      }
+      const record = byId.get(dependantId);
+      if (!record) return;
+      const hit = standingOf.get(dependantId);
+      const entry = {
+        conceptId: dependantId,
+        title: record.frontmatter.title ?? null,
+        standing: hit?.standing ?? "unsettled",
+        warnings: hit?.warnings ?? [],
+        depth,
+        via: [edge]
+      };
+      reached.set(dependantId, entry);
+      if (entry.standing === "superseded" || entry.standing === "rejected") {
+        stopped.push(dependantId);
+        return;
+      }
+      next.push(dependantId);
+    };
+    for (const id of frontier) {
+      for (const edge of inbound.get(id) ?? []) {
+        if (!rels.has(edge.rel)) continue;
+        if (dependantEnd(edge.rel) !== "source") continue;
+        consider(edge.from, { source: edge.from, target: id, rel: edge.rel });
+      }
+      for (const link2 of byId.get(id)?.frontmatter.strauss_links ?? []) {
+        if (!rels.has(link2.rel)) continue;
+        if (dependantEnd(link2.rel) !== "target") continue;
+        if (link2.target === id) continue;
+        consider(link2.target, {
+          source: id,
+          target: link2.target,
+          rel: link2.rel
+        });
+      }
+    }
+    frontier = next;
+  }
+  return {
+    root: targetId,
+    impacted: [...reached.values()].sort(
+      (left, right) => left.depth - right.depth || left.conceptId.localeCompare(right.conceptId)
+    ),
+    stopped: stopped.sort(),
+    truncated: frontier.length > 0,
+    unexpanded: [...frontier].sort()
+  };
+}
+function resolveRels(rels) {
+  if (!rels?.length) return new Set(KB_CAUSAL_LINK_RELS);
+  for (const rel of rels) {
+    if (!isKbLinkRel(rel) || LINK_RELS[rel].dependant === null) {
+      throw new KbUnknownLinkRelError(rel, KB_CAUSAL_LINK_RELS);
+    }
+  }
+  return new Set(rels);
+}
+function dependantEnd(rel) {
+  return isKbLinkRel(rel) ? LINK_RELS[rel].dependant : null;
+}
+function hasEdge(edges, edge) {
+  return edges.some(
+    (existing) => existing.source === edge.source && existing.target === edge.target && existing.rel === edge.rel
+  );
+}
+
+// src/commands/promote/standing.ts
+var WITHDRAWN = ["superseded", "rejected"];
+function standings(bundle) {
+  return new Map(
+    adjudicate(bundle, bundle).map((hit) => [
+      hit.record.conceptId,
+      hit.standing
+    ])
+  );
+}
+function isWithdrawn(standing) {
+  return standing !== void 0 && WITHDRAWN.includes(standing);
+}
+
+// src/commands/promote/candidates.ts
+var REVIEW_TAG = "review";
+var SETTLED = ["resolved"];
+function promoteCandidates(bundle) {
+  const inbound = inboundIndex(bundle);
+  const standing = standings(bundle);
+  const rows = [];
+  for (const record of bundle) {
+    if (isWithdrawn(standing.get(record.conceptId))) continue;
+    const why2 = candidateReason(record, inbound.get(record.conceptId) ?? []);
+    if (!why2) continue;
+    rows.push({
+      conceptId: record.conceptId,
+      type: recordType(record.conceptId),
+      title: record.frontmatter.title ?? null,
+      why: why2
+    });
+  }
+  return rows;
+}
+function candidateReason(record, inbound) {
+  const { strauss_status: status, tags } = record.frontmatter;
+  switch (recordType(record.conceptId)) {
+    case "decision":
+      if (isNoDecisionRecord(record)) return null;
+      return tags?.includes(REVIEW_TAG) ? null : "decision no longer under review";
+    case "constraint":
+      return status === "proposed" ? "constraint still proposed \u2014 the target base is where it settles" : null;
+    case "contract":
+      return "contract \u2014 it outlives the change that introduced it";
+    case "requirement":
+      return inbound.some((edge) => edge.rel === "satisfies") ? "requirement something in the base satisfies" : null;
+    case "risk":
+      return record.frontmatter.strauss_materiality === "blocking" && !SETTLED.includes(status) ? "blocking risk still open" : null;
+    default:
+      return null;
+  }
+}
+function recordType(conceptId2) {
+  return conceptId2.slice(0, conceptId2.indexOf("."));
+}
+
+// src/commands/promote/model.ts
+var import_zod26 = require("zod");
+var promoteInputSchema = import_zod26.z.object({
+  bundlePath,
+  conceptIds: import_zod26.z.array(conceptId).max(64).optional().describe("Records to copy into the target base. Omit with `list`."),
+  to: import_zod26.z.string().min(1).optional().describe("Absolute path to the base being promoted into."),
+  source: import_zod26.z.string().min(1).optional().describe(
+    "Where the promotion came from, usually the pull request URL. Recorded on each copy as a source."
+  ),
+  force: import_zod26.z.boolean().optional().describe("Overwrite a record the target base already holds."),
+  list: import_zod26.z.boolean().optional().describe("List the source base's candidates instead of promoting.")
+}).refine((input) => input.list === true || input.to !== void 0, {
+  message: "promote needs a target base \u2014 pass --to <bundle>, or --list",
+  path: ["to"]
+}).refine(
+  (input) => input.list === true || (input.conceptIds?.length ?? 0) > 0,
+  {
+    message: "name at least one concept id to promote, or pass --list",
+    path: ["conceptIds"]
+  }
+);
+
+// src/commands/promote/command.ts
+var promoteCommand = define({
+  name: "promote",
+  tool: "kb_promote",
+  usage: "promote <concept-id...> --to <bundle> [--source <url>] [--force] | --list",
+  description: "Copy records into another base at the same slug, with the review tags dropped and a source naming where the promotion came from. Use at merge, to lift what a review base settled into the base that outlives it. `list` names the candidates instead. The originals stay put.",
+  input: promoteInputSchema,
+  fromArgv: (argv, path) => {
+    const to = argvFlag(argv, "--to");
+    const source = argvFlag(argv, "--source");
+    const words = argv.slice(1);
+    for (const flag of ["--to", "--source"]) {
+      const at2 = words.indexOf(flag);
+      if (at2 !== -1) words.splice(at2, 2);
+    }
+    const conceptIds = words.filter((word) => !word.startsWith("--"));
+    return {
+      bundlePath: path,
+      ...conceptIds.length ? { conceptIds } : {},
+      ...to !== void 0 ? { to } : {},
+      ...source !== void 0 ? { source } : {},
+      ...argv.includes("--force") ? { force: true } : {},
+      ...argv.includes("--list") ? { list: true } : {}
+    };
+  },
+  run: async ({ store, actor }, { bundlePath: path, conceptIds, to, source, force, list }) => {
+    const from = (0, import_node_path12.resolve)(path);
+    const bundle = await store.list(from);
+    if (list) {
+      return { mode: "list", candidates: promoteCandidates(bundle) };
+    }
+    const target = (0, import_node_path12.resolve)(to);
+    if (target === from) throw new KbPromoteSelfError(target);
+    const named = (conceptIds ?? []).map(namedRecord);
+    const wanted = named.map(({ conceptId: conceptId2, type, slug }) => {
+      const record = bundle.find((entry) => entry.conceptId === conceptId2);
+      if (!record) throw new KbRecordNotFoundError(conceptId2);
+      return { record, type, slug };
+    });
+    await assertBaseNotFrozen(process.cwd(), from);
+    await assertBaseNotFrozen(process.cwd(), target);
+    const standing = standings(bundle);
+    for (const { record } of wanted) {
+      const where = standing.get(record.conceptId);
+      if (isWithdrawn(where)) {
+        throw new KbPromoteStandingError(record.conceptId, where);
+      }
+      if (!force && await store.read(target, record.conceptId)) {
+        throw new KbPromoteCollisionError(record.conceptId, target);
+      }
+    }
+    const promotedIds = new Set(wanted.map(({ record }) => record.conceptId));
+    const promoted = [];
+    for (const { record, type, slug } of wanted) {
+      const { frontmatter, body, droppedLinks } = carry(
+        record,
+        promotedIds,
+        source
+      );
+      try {
+        await store.write(
+          target,
+          { type, slug, frontmatter, body, overwrite: force === true },
+          actor
+        );
+      } catch (error) {
+        throw new KbPromoteStoppedError(
+          record.conceptId,
+          promoted.map((entry) => entry.conceptId),
+          error instanceof Error ? error.message : "unknown"
+        );
+      }
+      await store.note(target, {
+        by: actor,
+        operation: "promote-in",
+        conceptId: record.conceptId,
+        target: from
+      });
+      await store.note(from, {
+        by: actor,
+        operation: "promote-out",
+        conceptId: record.conceptId,
+        target
+      });
+      promoted.push({ conceptId: record.conceptId, droppedLinks });
+    }
+    return { mode: "promote", to: target, promoted };
+  },
+  render: (result) => renderPromote(result)
+});
+function namedRecord(conceptId2) {
+  const at2 = conceptId2.indexOf(".");
+  const type = at2 === -1 ? conceptId2 : conceptId2.slice(0, at2);
+  const slug = at2 === -1 ? "" : conceptId2.slice(at2 + 1);
+  if (!KB_SLUG_PATTERN.test(type) || !KB_SLUG_PATTERN.test(slug)) {
+    throw new KbInvalidConceptIdError(
+      "concept id must be <type>.<slug>, both kebab-case",
+      { conceptId: conceptId2 }
+    );
+  }
+  return { conceptId: conceptId2, type, slug };
+}
+function renderPromote(result) {
+  if (result.mode === "list") {
+    if (!result.candidates.length) return "No promotion candidates.";
+    return result.candidates.flatMap((candidate) => [
+      `${candidate.conceptId} [${candidate.type}]${candidate.title ? ` \u2014 ${candidate.title}` : ""}`,
+      `  ${candidate.why}`
+    ]).join("\n");
+  }
+  const lines = [
+    `Promoted ${result.promoted.length} record${result.promoted.length === 1 ? "" : "s"} into ${result.to}.`
+  ];
+  for (const entry of result.promoted) {
+    lines.push(`- ${entry.conceptId}`);
+    for (const link2 of entry.droppedLinks) {
+      lines.push(
+        `  dropped ${link2.rel} \u2192 ${link2.target} (not promoted in this run)`
+      );
+    }
+  }
+  return lines.join("\n");
+}
+
 // src/commands/query.ts
-var import_zod22 = require("zod");
+var import_zod27 = require("zod");
 var queryCommand = define({
   name: "query",
   tool: "kb_query",
   usage: "query <text...> [--tag T]... [--repo-root PATH]",
   description: "Search; every hit carries its standing. Flagged, never filtered: a superseded hit returns with its replacement, a rejected one is marked. Prefer kb_load when the base fits its budget \u2014 a full read beats search. Results are volatile: place them at the tail, not the cached prefix. Never read record files directly.",
-  input: import_zod22.z.object({
+  input: import_zod27.z.object({
     bundlePath,
-    text: import_zod22.z.string().optional(),
-    type: import_zod22.z.enum(KB_RECORD_TYPES).optional(),
-    includeNonCurrent: import_zod22.z.boolean().optional(),
+    text: import_zod27.z.string().optional(),
+    type: import_zod27.z.enum(KB_RECORD_TYPES).optional(),
+    includeNonCurrent: import_zod27.z.boolean().optional(),
     tags: TAGS,
     repoRoot: REPO_ROOT
   }),
@@ -5004,27 +6696,27 @@ var queryCommand = define({
 });
 
 // src/commands/read-index.ts
-var import_zod23 = require("zod");
+var import_zod28 = require("zod");
 var readIndexCommand = define({
   name: "index",
   tool: "kb_index",
   usage: "index",
   description: "The index \u2014 title, type, status, description per record \u2014 rebuilt if stale. Cheapest re-orientation after compaction: call it (or kb_context) first, then kb_load or fetch by id.",
-  input: import_zod23.z.object({ bundlePath }),
+  input: import_zod28.z.object({ bundlePath }),
   fromArgv: (_argv, path) => ({ bundlePath: path }),
   run: ({ store }, { bundlePath: path }) => store.readIndex(path)
 });
 
 // src/commands/schema.ts
-var import_zod26 = require("zod");
+var import_zod31 = require("zod");
 
 // src/json-schema.ts
-var import_zod25 = require("zod");
+var import_zod30 = require("zod");
 
 // src/kb-log.ts
-var import_zod24 = require("zod");
+var import_zod29 = require("zod");
 var LOG_FILE = "log.jsonl";
-var kbLogEntrySchema = import_zod24.z.object({
+var kbLogEntrySchema = import_zod29.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
@@ -5033,23 +6725,32 @@ var kbLogEntrySchema = import_zod24.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_zod24.z.iso.datetime(),
-  by: import_zod24.z.string().min(1),
-  operation: import_zod24.z.string().min(1),
-  conceptId: import_zod24.z.string().min(1),
-  /** Second concept id, where the operation relates two — supersession. */
-  target: import_zod24.z.string().min(1).optional()
+  at: import_zod29.z.iso.datetime(),
+  by: import_zod29.z.string().min(1),
+  operation: import_zod29.z.string().min(1),
+  conceptId: import_zod29.z.string().min(1),
+  /**
+   * The operation's other end, where it has one: a second concept id for
+   * supersession, the other base's path for promotion.
+   */
+  target: import_zod29.z.string().min(1).optional()
 }).strict();
 function renderLogEntry(entry) {
   return `${JSON.stringify(kbLogEntrySchema.parse(entry))}
 `;
 }
+var CONFLICT_MARKER = /^(<{7}|\|{7}|={7}|>{7})/;
 function parseLog(raw) {
   const entries = [];
   const malformed = [];
   const seen = /* @__PURE__ */ new Set();
+  let conflicted = false;
   raw.split("\n").forEach((text, index2) => {
     if (!text.trim()) return;
+    if (CONFLICT_MARKER.test(text)) {
+      conflicted = true;
+      return;
+    }
     let value;
     try {
       value = JSON.parse(text);
@@ -5062,25 +6763,25 @@ function parseLog(raw) {
       malformed.push({ line: index2 + 1, text });
       return;
     }
-    const key = JSON.stringify(parsed.data);
-    if (seen.has(key)) return;
-    seen.add(key);
+    const key2 = JSON.stringify(parsed.data);
+    if (seen.has(key2)) return;
+    seen.add(key2);
     entries.push(parsed.data);
   });
   entries.sort(
     (left, right) => left.at < right.at ? -1 : left.at > right.at ? 1 : 0
   );
-  return { entries, malformed };
+  return { entries, malformed, conflicted };
 }
 
 // src/json-schema.ts
 function kbJsonSchemas() {
   return {
-    recordFrontmatter: import_zod25.z.toJSONSchema(kbRecordFrontmatterSchema, {
+    recordFrontmatter: import_zod30.z.toJSONSchema(kbRecordFrontmatterSchema, {
       io: "input"
     }),
-    composeInput: import_zod25.z.toJSONSchema(composeInputSchema, { io: "input" }),
-    logEntry: import_zod25.z.toJSONSchema(kbLogEntrySchema, { io: "input" })
+    composeInput: import_zod30.z.toJSONSchema(composeInputSchema, { io: "input" }),
+    logEntry: import_zod30.z.toJSONSchema(kbLogEntrySchema, { io: "input" })
   };
 }
 
@@ -5090,25 +6791,25 @@ var schemaCommand = define({
   tool: "kb_schema",
   usage: "schema",
   description: "JSON Schema for frontmatter, write input, and log entries, generated from the enforcing code.",
-  input: import_zod26.z.object({}),
+  input: import_zod31.z.object({}),
   fromArgv: () => ({}),
   run: () => Promise.resolve(kbJsonSchemas())
 });
 
 // src/commands/stamp.ts
-var import_promises8 = require("fs/promises");
-var import_zod27 = require("zod");
+var import_promises10 = require("fs/promises");
+var import_zod32 = require("zod");
 var DIGEST = /^[0-9a-f]{64}$/;
 var stampCommand = define({
   name: "stamp",
   tool: "kb_stamp",
   usage: "stamp [--bundle PATH] [--since DIGEST|FILE]",
   description: "Content stamp of a base \u2014 `load`'s digest, record counts, per-record digests, how many records have drifted anchors \u2014 without any bodies. Takes no bundlePath to stamp every pinned base. With `since`, reports only the bases that moved, naming the changed ids. Reads, never writes.",
-  input: import_zod27.z.object({
-    bundlePath: import_zod27.z.string().min(1).optional().describe(
+  input: import_zod32.z.object({
+    bundlePath: import_zod32.z.string().min(1).optional().describe(
       "Absolute path to one knowledge base. Omit to stamp every pinned base."
     ),
-    since: import_zod27.z.string().min(1).optional().describe(
+    since: import_zod32.z.string().min(1).optional().describe(
       "Prior digest, or path to a prior `stamp --json`; only moved bases return, with changed ids when the baseline is a file."
     )
   }),
@@ -5170,7 +6871,7 @@ async function readBaseline(since) {
   if (DIGEST.test(since)) return { digest: since, byPath: /* @__PURE__ */ new Map() };
   let parsed;
   try {
-    parsed = JSON.parse(await (0, import_promises8.readFile)(since, "utf8"));
+    parsed = JSON.parse(await (0, import_promises10.readFile)(since, "utf8"));
   } catch {
     throw new KbStampBaselineError(since);
   }
@@ -5194,16 +6895,16 @@ async function readBaseline(since) {
 }
 
 // src/commands/status.ts
-var import_zod28 = require("zod");
+var import_zod33 = require("zod");
 var statusCommand = define({
   name: "status",
   tool: "kb_status",
   usage: "status <concept-id> <status>",
   description: "Move a record's status. Compare-and-swap: a concurrent change fails instead of being overwritten.",
-  input: import_zod28.z.object({
+  input: import_zod33.z.object({
     bundlePath,
     conceptId,
-    status: import_zod28.z.enum(KB_RECORD_STATUSES)
+    status: import_zod33.z.enum(KB_RECORD_STATUSES)
   }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
@@ -5218,13 +6919,13 @@ var statusCommand = define({
 });
 
 // src/commands/supersede.ts
-var import_zod29 = require("zod");
+var import_zod34 = require("zod");
 var supersedeCommand = define({
   name: "supersede",
   tool: "kb_supersede",
   usage: "supersede <concept-id> <replacement-id>",
   description: "Mark a record superseded by another, linked in both directions. Use instead of editing a record whose meaning changed.",
-  input: import_zod29.z.object({ bundlePath, conceptId, replacementId: conceptId }),
+  input: import_zod34.z.object({ bundlePath, conceptId, replacementId: conceptId }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
     conceptId: argv[1],
@@ -5237,17 +6938,153 @@ var supersedeCommand = define({
   }
 });
 
+// src/commands/sweep.ts
+var import_zod35 = require("zod");
+var TERMINAL = [
+  "resolved",
+  "rejected",
+  "superseded"
+];
+var sweepCommand = define({
+  name: "sweep",
+  tool: "kb_sweep",
+  usage: "sweep --tag <tag> --terminal [--dry-run]",
+  description: "Delete tagged records that are resolved, rejected or superseded. Refuses without --tag, keeps any record a surviving record still points at, and logs each deletion.",
+  input: import_zod35.z.object({
+    bundlePath,
+    tag: import_zod35.z.string({ error: "sweep needs --tag: it never sweeps a whole base" }).min(1).describe("Only records carrying this tag are considered."),
+    terminal: import_zod35.z.literal(true, {
+      error: "sweep needs --terminal: it deletes only settled records"
+    }).describe(
+      "Required. Names the only scope sweep deletes: resolved, rejected and superseded records."
+    ),
+    dryRun: import_zod35.z.boolean().optional().describe("Report what would go, and delete nothing.")
+  }),
+  fromArgv: (argv, path) => ({
+    bundlePath: path,
+    tag: argvFlag(argv, "--tag"),
+    ...argv.includes("--terminal") ? { terminal: true } : {},
+    ...argv.includes("--dry-run") ? { dryRun: true } : {}
+  }),
+  run: async ({ store, actor }, { bundlePath: path, tag, dryRun }) => {
+    const bundle = await store.list(path);
+    const held = holderIndex(bundle);
+    const candidates = adjudicate(bundle, bundle).filter(
+      (hit) => sweepable(hit, tag)
+    );
+    const doomed = new Set(candidates.map((hit) => hit.record.conceptId));
+    let changed = true;
+    while (changed) {
+      changed = false;
+      for (const conceptId2 of [...doomed]) {
+        if (survivorsHolding(conceptId2, held, doomed).length === 0) continue;
+        doomed.delete(conceptId2);
+        changed = true;
+      }
+    }
+    const skipped = candidates.filter((hit) => !doomed.has(hit.record.conceptId)).map((hit) => ({
+      conceptId: hit.record.conceptId,
+      heldBy: survivorsHolding(hit.record.conceptId, held, doomed)
+    }));
+    const ordered = [...doomed].sort();
+    if (dryRun) {
+      return {
+        tag,
+        dryRun: true,
+        deleted: [],
+        candidates: ordered,
+        skipped,
+        failed: []
+      };
+    }
+    await assertBaseNotFrozen(process.cwd(), path);
+    const deleted = [];
+    const failed = [];
+    try {
+      for (const conceptId2 of ordered) {
+        try {
+          const outcome = await store.deleteRecord(
+            path,
+            conceptId2,
+            { tag, statuses: TERMINAL },
+            actor
+          );
+          if (outcome === "deleted") deleted.push(conceptId2);
+          else failed.push({ conceptId: conceptId2, reason: outcome });
+        } catch (error) {
+          failed.push({
+            conceptId: conceptId2,
+            reason: error instanceof Error ? error.message : "unknown"
+          });
+        }
+      }
+    } finally {
+      await store.readIndex(path);
+      await store.dropSearchIndex(path);
+    }
+    return {
+      tag,
+      dryRun: false,
+      deleted,
+      candidates: ordered,
+      skipped,
+      failed
+    };
+  },
+  render: (result) => renderSweep(result)
+});
+function sweepable(hit, tag) {
+  const { tags, strauss_status } = hit.record.frontmatter;
+  return (tags ?? []).includes(tag) && // Supersession is a standing, settled against the whole base; the other
+  // two are the record's own word for itself.
+  (hit.standing === "superseded" || strauss_status === "resolved" || strauss_status === "rejected");
+}
+function holderIndex(bundle) {
+  const byTarget = /* @__PURE__ */ new Map();
+  const hold = (target, from) => {
+    if (target === from) return;
+    const holders = byTarget.get(target) ?? /* @__PURE__ */ new Set();
+    holders.add(from);
+    byTarget.set(target, holders);
+  };
+  for (const [target, edges] of inboundIndex(bundle)) {
+    for (const edge of edges) hold(target, edge.from);
+  }
+  for (const record of bundle) {
+    const { strauss_supersedes, strauss_superseded_by } = record.frontmatter;
+    for (const old of strauss_supersedes ?? []) hold(old, record.conceptId);
+    if (strauss_superseded_by) hold(strauss_superseded_by, record.conceptId);
+  }
+  return byTarget;
+}
+function survivorsHolding(conceptId2, held, doomed) {
+  return [...held.get(conceptId2) ?? []].filter((from) => !doomed.has(from)).sort();
+}
+function renderSweep(result) {
+  const shown = result.dryRun ? result.candidates : result.deleted;
+  const verb = result.dryRun ? "would delete" : "deleted";
+  const lines = [`${verb} ${shown.length} (tag: ${result.tag})`];
+  for (const conceptId2 of shown) lines.push(`- ${conceptId2}`);
+  for (const skip of result.skipped) {
+    lines.push(`kept ${skip.conceptId} \u2014 held by ${skip.heldBy.join(", ")}`);
+  }
+  for (const failure of result.failed) {
+    lines.push(`failed ${failure.conceptId} \u2014 ${failure.reason}`);
+  }
+  return lines.join("\n");
+}
+
 // src/commands/sync-instructions.ts
-var import_zod30 = require("zod");
+var import_zod36 = require("zod");
 var syncInstructionsCommand = define({
   name: "sync-instructions",
   usage: "sync-instructions <file> [--profile NAME] [--budget N] [--full-under N]",
   description: "CLI-only: plant the kb_context block between sentinel comments in AGENTS.md or CLAUDE.md, idempotently.",
-  input: import_zod30.z.object({
-    file: import_zod30.z.string().min(1).describe("The instruction file to edit in place."),
-    budgetTokens: import_zod30.z.number().int().positive().optional(),
-    fullUnderTokens: import_zod30.z.number().int().positive().optional(),
-    profile: import_zod30.z.string().optional()
+  input: import_zod36.z.object({
+    file: import_zod36.z.string().min(1).describe("The instruction file to edit in place."),
+    budgetTokens: import_zod36.z.number().int().positive().optional(),
+    fullUnderTokens: import_zod36.z.number().int().positive().optional(),
+    profile: import_zod36.z.string().optional()
   }),
   fromArgv: (argv) => {
     const budget = argvFlag(argv, "--budget");
@@ -5273,7 +7110,7 @@ var syncInstructionsCommand = define({
 });
 
 // src/commands/trace.ts
-var import_zod31 = require("zod");
+var import_zod37 = require("zod");
 
 // src/trace.ts
 var TRACE_EDGES = [
@@ -5329,11 +7166,11 @@ var traceCommand = define({
   tool: "kb_trace",
   usage: "trace <concept-id> [edges...]",
   description: 'Timeline of how a position was reached, ordered by write time, following supersession, shared anchors and shared sources. Includes rejected, draft and superseded records \u2014 in a history they are the content. For "why is it like this"; kb_load answers "what holds now".',
-  input: import_zod31.z.object({
+  input: import_zod37.z.object({
     bundlePath,
     conceptId,
-    edges: import_zod31.z.array(import_zod31.z.enum(TRACE_EDGES)).optional(),
-    depth: import_zod31.z.number().int().positive().optional()
+    edges: import_zod37.z.array(import_zod37.z.enum(TRACE_EDGES)).optional(),
+    depth: import_zod37.z.number().int().positive().optional()
   }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
@@ -5355,37 +7192,37 @@ var traceCommand = define({
 });
 
 // src/commands/types.ts
-var import_zod32 = require("zod");
+var import_zod38 = 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_zod32.z.object({}),
+  input: import_zod38.z.object({}),
   fromArgv: () => ({}),
   run: () => Promise.resolve(RECORD_TYPES)
 });
 
 // src/commands/unpin.ts
-var import_zod33 = require("zod");
+var import_zod39 = require("zod");
 var unpinCommand = define({
   name: "unpin",
   tool: "kb_unpin",
   usage: "unpin [bundle-path]",
   description: "Remove a base from every manifest layer that holds it. Reports the layers touched.",
-  input: import_zod33.z.object({ bundlePath }),
+  input: import_zod39.z.object({ bundlePath }),
   fromArgv: (argv, path) => ({ bundlePath: argv[1] ?? path }),
   run: (_ctx, { bundlePath: path }) => unpinBase(process.cwd(), path)
 });
 
 // src/commands/validate.ts
-var import_zod34 = require("zod");
+var import_zod40 = require("zod");
 var validateCommand = define({
   name: "validate",
   tool: "kb_validate",
   usage: "validate",
   description: "Check pointers no single record can see: supersession links that disagree between the two records, typed causal links, and assumptions that cite sources. Each finding carries a severity: errors fail the exit code, warnings do not.",
-  input: import_zod34.z.object({ bundlePath }),
+  input: import_zod40.z.object({ bundlePath }),
   fromArgv: (_argv, path) => ({ bundlePath: path }),
   run: async ({ store }, { bundlePath: path }) => validateBundle(await store.list(path)),
   // Warnings never fail the exit code; every other severity does.
@@ -5395,16 +7232,16 @@ var validateCommand = define({
 });
 
 // src/commands/verify.ts
-var import_zod35 = require("zod");
+var import_zod41 = require("zod");
 var verifyCommand = define({
   name: "verify",
   tool: "kb_verify",
   usage: "verify <concept-id> --note <text>",
   description: "Append a verified[] event: who checked, when, and what was found. Append-only. A record's own generator is refused unless the actor is `human:`-prefixed.",
-  input: import_zod35.z.object({
+  input: import_zod41.z.object({
     bundlePath,
     conceptId,
-    note: import_zod35.z.string().refine((s) => s.trim().length > 0, {
+    note: import_zod41.z.string().refine((s) => s.trim().length > 0, {
       message: "note must say what the check found"
     })
   }),
@@ -5424,15 +7261,15 @@ var verifyCommand = define({
 });
 
 // src/commands/write.ts
-var import_zod36 = require("zod");
+var import_zod42 = require("zod");
 var writeCommand = define({
   name: "write",
   tool: "kb_write",
   usage: "write <type> < record.json",
   description: "Write one record. Search first \u2014 a duplicate concept id is rejected, not overwritten; kb_types lists each type's sections. An unsourced claim is an `assumption` with assumption: true, never a vague `fact`. Conflicting records get a `risk`, `open-question`, or superseding `decision`. Prefer a new short record over overloading one. Never delete; supersede.",
-  input: import_zod36.z.object({
+  input: import_zod42.z.object({
     bundlePath,
-    type: import_zod36.z.enum(KB_RECORD_TYPES),
+    type: import_zod42.z.enum(KB_RECORD_TYPES),
     input: composeInputSchema
   }),
   fromArgv: async (argv, path, stdin) => ({
@@ -5456,13 +7293,13 @@ var writeCommand = define({
 });
 
 // src/commands/write-decision.ts
-var import_zod37 = require("zod");
+var import_zod43 = require("zod");
 var writeDecisionCommand = define({
   name: "write-decision",
   tool: "kb_write_decision",
   usage: "write-decision < decision.json",
   description: "Write a decision, with `alternative` (what was rejected and why) and `impact` as fields. Record one when a later reader would otherwise simplify the constraint away; skip when the diff already answers it. `sources` for material read, `anchors` for code, `relatedConceptIds` for records.",
-  input: import_zod37.z.object({ bundlePath, input: decisionInputSchema }),
+  input: import_zod43.z.object({ bundlePath, input: decisionInputSchema }),
   fromArgv: async (_argv, path, stdin) => ({
     bundlePath: path,
     input: JSON.parse(await stdin())
@@ -5493,19 +7330,24 @@ var KB_COMMANDS = [
   verifyCommand,
   anchorResolveCommand,
   reassessCommand,
+  promoteCommand,
   loadCommand,
   catalogCommand,
   packCommand,
+  exportCommand,
   queryCommand,
   traceCommand,
   impactCommand,
   backlinksCommand,
+  matchCommand,
+  classifyCommand,
   listCommand,
   readIndexCommand,
   logCommand,
   stampCommand,
   validateCommand,
   doctorCommand,
+  sweepCommand,
   schemaCommand,
   pinCommand,
   unpinCommand,
@@ -5519,8 +7361,8 @@ var KB_COMMANDS_BY_NAME = new Map(
 );
 
 // src/kb-store.ts
-var import_promises10 = require("fs/promises");
-var import_node_path11 = require("path");
+var import_promises12 = require("fs/promises");
+var import_node_path14 = require("path");
 
 // src/markdown.ts
 var import_gray_matter = __toESM(require("gray-matter"), 1);
@@ -5580,8 +7422,8 @@ function bundleDigest(records, superseded) {
 }
 
 // src/search-index.ts
-var import_promises9 = require("fs/promises");
-var import_node_path10 = require("path");
+var import_promises11 = require("fs/promises");
+var import_node_path13 = require("path");
 var SEARCH_INDEX_FILE = ".index.sqlite";
 var COLLECTION = "kb";
 async function searchBase(bundlePath2, query, options = {}) {
@@ -5590,7 +7432,7 @@ async function searchBase(bundlePath2, query, options = {}) {
   let store = null;
   try {
     store = await qmd.createStore({
-      dbPath: (0, import_node_path10.join)(bundlePath2, SEARCH_INDEX_FILE),
+      dbPath: (0, import_node_path13.join)(bundlePath2, SEARCH_INDEX_FILE),
       config: {
         collections: {
           [COLLECTION]: {
@@ -5625,16 +7467,16 @@ async function searchBase(bundlePath2, query, options = {}) {
   }
 }
 async function isStale(bundlePath2) {
-  const indexAt = await (0, import_promises9.stat)((0, import_node_path10.join)(bundlePath2, SEARCH_INDEX_FILE)).then((s) => s.mtimeMs).catch(() => 0);
+  const indexAt = await (0, import_promises11.stat)((0, import_node_path13.join)(bundlePath2, SEARCH_INDEX_FILE)).then((s) => s.mtimeMs).catch(() => 0);
   if (!indexAt) return true;
-  const { readdir: readdir2 } = await import("fs/promises");
-  const names = (await readdir2(bundlePath2).catch(() => [])).filter(
+  const { readdir: readdir3 } = await import("fs/promises");
+  const names = (await readdir3(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 at2 = await (0, import_promises9.stat)((0, import_node_path10.join)(bundlePath2, name)).then((s) => s.mtimeMs).catch(() => 0);
+    const at2 = await (0, import_promises11.stat)((0, import_node_path13.join)(bundlePath2, name)).then((s) => s.mtimeMs).catch(() => 0);
     if (at2 > indexAt) stale = true;
   });
   return stale;
@@ -5752,144 +7594,13 @@ function typeRank(record) {
   return index2 === -1 ? TYPE_PRIORITY.length : index2;
 }
 
-// src/kb-links/inbound.ts
-function inboundIndex(bundle) {
-  const byTarget = /* @__PURE__ */ new Map();
-  for (const record of bundle) {
-    for (const link2 of record.frontmatter.strauss_links ?? []) {
-      if (link2.target === record.conceptId) continue;
-      const edges = byTarget.get(link2.target) ?? [];
-      if (edges.some(
-        (edge) => edge.from === record.conceptId && edge.rel === link2.rel
-      )) {
-        continue;
-      }
-      edges.push({ from: record.conceptId, rel: link2.rel });
-      byTarget.set(link2.target, edges);
-    }
-  }
-  return byTarget;
-}
-
-// src/kb-links/backlinks.ts
-function backlinks(targetId, bundle) {
-  const byId = new Map(bundle.map((record) => [record.conceptId, record]));
-  if (!byId.has(targetId)) throw new KbRecordNotFoundError(targetId);
-  const standingOf = new Map(
-    adjudicate(bundle, bundle).map((hit) => [hit.record.conceptId, hit])
-  );
-  const rows = [];
-  for (const edge of inboundIndex(bundle).get(targetId) ?? []) {
-    const record = byId.get(edge.from);
-    if (!record) continue;
-    const hit = standingOf.get(edge.from);
-    rows.push({
-      ...edge,
-      title: record.frontmatter.title ?? null,
-      standing: hit?.standing ?? "unsettled",
-      warnings: hit?.warnings ?? []
-    });
-  }
-  return {
-    target: targetId,
-    backlinks: rows.sort(
-      (left, right) => left.from.localeCompare(right.from) || left.rel.localeCompare(right.rel)
-    )
-  };
-}
-
-// src/kb-links/impact.ts
-function impact(targetId, bundle, options = {}) {
-  const byId = new Map(bundle.map((record) => [record.conceptId, record]));
-  if (!byId.has(targetId)) throw new KbRecordNotFoundError(targetId);
-  const rels = resolveRels(options.rels);
-  const maxDepth = options.depth ?? Number.POSITIVE_INFINITY;
-  const inbound = inboundIndex(bundle);
-  const standingOf = new Map(
-    adjudicate(bundle, bundle).map((hit) => [hit.record.conceptId, hit])
-  );
-  const reached = /* @__PURE__ */ new Map();
-  const stopped = [];
-  let frontier = [targetId];
-  let depth = 0;
-  while (frontier.length && depth < maxDepth) {
-    depth += 1;
-    const next = [];
-    const consider = (dependantId, edge) => {
-      if (dependantId === targetId) return;
-      const existing = reached.get(dependantId);
-      if (existing) {
-        if (!hasEdge(existing.via, edge)) existing.via.push(edge);
-        return;
-      }
-      const record = byId.get(dependantId);
-      if (!record) return;
-      const hit = standingOf.get(dependantId);
-      const entry = {
-        conceptId: dependantId,
-        title: record.frontmatter.title ?? null,
-        standing: hit?.standing ?? "unsettled",
-        warnings: hit?.warnings ?? [],
-        depth,
-        via: [edge]
-      };
-      reached.set(dependantId, entry);
-      if (entry.standing === "superseded" || entry.standing === "rejected") {
-        stopped.push(dependantId);
-        return;
-      }
-      next.push(dependantId);
-    };
-    for (const id of frontier) {
-      for (const edge of inbound.get(id) ?? []) {
-        if (!rels.has(edge.rel)) continue;
-        if (dependantEnd(edge.rel) !== "source") continue;
-        consider(edge.from, { source: edge.from, target: id, rel: edge.rel });
-      }
-      for (const link2 of byId.get(id)?.frontmatter.strauss_links ?? []) {
-        if (!rels.has(link2.rel)) continue;
-        if (dependantEnd(link2.rel) !== "target") continue;
-        if (link2.target === id) continue;
-        consider(link2.target, {
-          source: id,
-          target: link2.target,
-          rel: link2.rel
-        });
-      }
-    }
-    frontier = next;
-  }
-  return {
-    root: targetId,
-    impacted: [...reached.values()].sort(
-      (left, right) => left.depth - right.depth || left.conceptId.localeCompare(right.conceptId)
-    ),
-    stopped: stopped.sort(),
-    truncated: frontier.length > 0,
-    unexpanded: [...frontier].sort()
-  };
-}
-function resolveRels(rels) {
-  if (!rels?.length) return new Set(KB_CAUSAL_LINK_RELS);
-  for (const rel of rels) {
-    if (!isKbLinkRel(rel) || LINK_RELS[rel].dependant === null) {
-      throw new KbUnknownLinkRelError(rel, KB_CAUSAL_LINK_RELS);
-    }
-  }
-  return new Set(rels);
-}
-function dependantEnd(rel) {
-  return isKbLinkRel(rel) ? LINK_RELS[rel].dependant : null;
-}
-function hasEdge(edges, edge) {
-  return edges.some(
-    (existing) => existing.source === edge.source && existing.target === edge.target && existing.rel === edge.rel
-  );
-}
+// src/kb-files.ts
+var STORE_OWNED_FILES = [INDEX_FILE, LOG_FILE, SEARCH_INDEX_FILE];
 
 // src/kb-gitattributes.ts
 var GITATTRIBUTES_FILE = ".gitattributes";
-var UNION_MERGE_LINE = `${LOG_FILE} text eol=lf merge=union`;
+var GENERATED = "linguist-generated";
+var UNION_MERGE_LINE = `${LOG_FILE} text eol=lf merge=union ${GENERATED}=true`;
 function parseLine(line) {
   const trimmed = line.trim();
   if (!trimmed || trimmed.startsWith("#")) return null;
@@ -5897,23 +7608,39 @@ function parseLine(line) {
   return pattern === void 0 ? null : { pattern, attrs };
 }
 function hasMergeDeclaration(contents) {
+  return declares(contents, LOG_FILE, "merge");
+}
+function declares(contents, pattern, attribute) {
   return contents.split("\n").some((line) => {
     const parsed = parseLine(line);
-    if (!parsed || parsed.pattern !== LOG_FILE) return false;
+    if (!parsed || parsed.pattern !== pattern) return false;
     return parsed.attrs.some(
-      (attr) => attr === "merge" || attr === "-merge" || attr.startsWith("merge=")
+      (attr) => attr === attribute || attr === `-${attribute}` || attr.startsWith(`${attribute}=`)
     );
   });
 }
-function appendUnionMergeLine(contents) {
+function missingGitattributesLines(contents) {
+  const needsMerge = !hasMergeDeclaration(contents);
+  const generated = STORE_OWNED_FILES.filter(
+    // The union-merge line carries the log's `linguist-generated` too, so the
+    // log needs its own line only where that line is already there without it.
+    (file) => !(needsMerge && file === LOG_FILE)
+  ).filter((file) => !declares(contents, file, GENERATED)).map((file) => `${file} ${GENERATED}=true`);
+  return needsMerge ? [UNION_MERGE_LINE, ...generated] : generated;
+}
+var GITATTRIBUTES_BLOCK = `${missingGitattributesLines("").join("\n")}
+`;
+function appendGitattributesLines(contents) {
+  const lines = missingGitattributesLines(contents);
+  if (lines.length === 0) return "";
   const separator = contents.length === 0 || contents.endsWith("\n") ? "" : "\n";
-  return `${separator}${UNION_MERGE_LINE}
+  return `${separator}${lines.join("\n")}
 `;
 }
 
 // src/kb-store.ts
-var KB_DIR = (0, import_node_path11.join)(".strauss", "kb");
-var STORE_OWNED = /* @__PURE__ */ new Set([INDEX_FILE, LOG_FILE, SEARCH_INDEX_FILE]);
+var KB_DIR = (0, import_node_path14.join)(".strauss", "kb");
+var STORE_OWNED = new Set(STORE_OWNED_FILES);
 var DEFAULT_LOAD_BUDGET = 25e3;
 var KbStore = class {
   constructor(logger = {}) {
@@ -5943,7 +7670,7 @@ var KbStore = class {
     const conceptId2 = `${input.type}.${input.slug}`;
     const root = this.root(bundlePath2);
     const target = this.recordPath(bundlePath2, conceptId2);
-    await (0, import_promises10.mkdir)(root, { recursive: true });
+    await (0, import_promises12.mkdir)(root, { recursive: true });
     await this.publish(
       target,
       stringifyMarkdownWithFrontmatter(input.body, frontmatter),
@@ -5982,7 +7709,7 @@ var KbStore = class {
     const target = this.recordPath(bundlePath2, conceptId2);
     let raw;
     try {
-      raw = await (0, import_promises10.readFile)(target, "utf8");
+      raw = await (0, import_promises12.readFile)(target, "utf8");
     } catch {
       return null;
     }
@@ -6002,7 +7729,7 @@ var KbStore = class {
     const root = this.root(bundlePath2);
     let names;
     try {
-      names = await (0, import_promises10.readdir)(root);
+      names = await (0, import_promises12.readdir)(root);
     } catch {
       return [];
     }
@@ -6010,7 +7737,7 @@ var KbStore = class {
     const records = await mapLimit(
       wanted,
       DEFAULT_IO_CONCURRENCY,
-      async ({ name, conceptId: conceptId2 }) => this.parse(conceptId2, await (0, import_promises10.readFile)((0, import_node_path11.join)(root, name), "utf8"))
+      async ({ name, conceptId: conceptId2 }) => this.parse(conceptId2, await (0, import_promises12.readFile)((0, import_node_path14.join)(root, name), "utf8"))
     );
     return records.filter(
       (record) => record !== null && matchesTags(record, filter)
@@ -6040,12 +7767,16 @@ var KbStore = class {
    * 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.
+   *
+   * Through the write schema: this is a write, and a defect a hand-edit put in
+   * the frontmatter must not be published back out under an actor stamp.
    */
   async updateAnchors(bundlePath2, conceptId2, anchors, actor = "unknown") {
+    const checked = anchors.map((anchor) => kbAnchorWriteSchema.parse(anchor));
     return this.mutate(
       bundlePath2,
       conceptId2,
-      (frontmatter) => ({ ...frontmatter, strauss_anchors: anchors }),
+      (frontmatter) => ({ ...frontmatter, strauss_anchors: checked }),
       { operation: "anchor-resolve", by: actor }
     );
   }
@@ -6131,6 +7862,35 @@ ${answer}
 `
     );
   }
+  /**
+   * Removes one record, logged as `sweep`. The only path in this store that
+   * deletes — see the specification for the scope that makes it safe.
+   *
+   * `expected` is re-read and re-checked immediately before the unlink, the
+   * compare-and-swap `mutate` makes: a record retagged or moved out of a
+   * terminal status since the caller listed it is reported, not removed.
+   */
+  async deleteRecord(bundlePath2, conceptId2, expected, actor = "unknown") {
+    const target = this.recordPath(bundlePath2, conceptId2);
+    const witness = await this.read(bundlePath2, conceptId2);
+    if (!witness) throw new KbRecordNotFoundError(conceptId2);
+    const { tags, strauss_status } = witness.frontmatter;
+    if (!(tags ?? []).includes(expected.tag) || !expected.statuses.includes(strauss_status)) {
+      return "changed-since-listing";
+    }
+    try {
+      await (0, import_promises12.unlink)(target);
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+      throw new KbRecordNotFoundError(conceptId2);
+    }
+    await this.record(this.root(bundlePath2), {
+      operation: "sweep",
+      by: actor,
+      conceptId: conceptId2
+    });
+    return "deleted";
+  }
   /**
    * Records matching a text query, each carrying its standing.
    *
@@ -6353,11 +8113,11 @@ ${answer}
   async readIndex(bundlePath2) {
     const root = this.root(bundlePath2);
     const expected = renderIndex(await this.list(bundlePath2));
-    const stored = await (0, import_promises10.readFile)((0, import_node_path11.join)(root, INDEX_FILE), "utf8").catch(
+    const stored = await (0, import_promises12.readFile)((0, import_node_path14.join)(root, INDEX_FILE), "utf8").catch(
       () => null
     );
     if (indexIsStale(stored, expected)) {
-      await this.publish((0, import_node_path11.join)(root, INDEX_FILE), expected, true, INDEX_FILE);
+      await this.publish((0, import_node_path14.join)(root, INDEX_FILE), expected, true, INDEX_FILE);
       this.logger.info?.({
         operation: "kb.index.repair",
         bundlePath: root,
@@ -6366,19 +8126,39 @@ ${answer}
     }
     return expected;
   }
+  /**
+   * Drops the derived search index, so the next search rebuilds it.
+   *
+   * `searchBase` re-indexes when a record is newer than the index, which no
+   * deletion makes true — a swept record would stay findable until some other
+   * record was written.
+   */
+  async dropSearchIndex(bundlePath2) {
+    await (0, import_promises12.unlink)((0, import_node_path14.join)(this.root(bundlePath2), SEARCH_INDEX_FILE)).catch(
+      () => void 0
+    );
+  }
   /**
    * The log, with unparseable lines reported rather than repaired.
    *
    * The log is the bundle's only artifact that cannot be reconstructed — the
    * records rebuild the index, and the code outlives both, but nothing else
    * knows which agent touched what. So a bad line is surfaced and left alone.
+   * Conflict markers are read past rather than reported per line.
    */
   async readLog(bundlePath2) {
-    const raw = await (0, import_promises10.readFile)(
-      (0, import_node_path11.join)(this.root(bundlePath2), LOG_FILE),
+    const raw = await (0, import_promises12.readFile)(
+      (0, import_node_path14.join)(this.root(bundlePath2), LOG_FILE),
       "utf8"
     ).catch(() => "");
     const result = parseLog(raw);
+    if (result.conflicted) {
+      this.logger.warn?.({
+        operation: "kb.log.parse",
+        bundlePath: this.root(bundlePath2),
+        outcome: "conflicted"
+      });
+    }
     for (const bad of result.malformed) {
       this.logger.warn?.({
         operation: "kb.log.parse",
@@ -6388,6 +8168,14 @@ ${answer}
     }
     return result;
   }
+  /**
+   * Appends one log entry for a move the store cannot see from one base.
+   * Promotion writes into a target base and has to be legible from the source
+   * base too, where nothing was written.
+   */
+  async note(bundlePath2, entry) {
+    await this.record(this.root(bundlePath2), entry);
+  }
   /**
    * `markSuperseded`, tolerant of the two ways it legitimately doesn't land:
    * a missing target (a broken link, legal per compose.ts) or a CAS conflict
@@ -6426,14 +8214,14 @@ ${answer}
   }
   async mutate(bundlePath2, conceptId2, change, entry, changeBody = (body) => body) {
     const target = this.recordPath(bundlePath2, conceptId2);
-    const before = await (0, import_promises10.readFile)(target, "utf8").catch(() => null);
+    const before = await (0, import_promises12.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_promises10.readFile)(target, "utf8").catch(() => null);
+    const witness = await (0, import_promises12.readFile)(target, "utf8").catch(() => null);
     if (witness === null || sha2563(witness) !== sha2563(before)) {
       throw new KbWriteConflictError(conceptId2);
     }
@@ -6459,26 +8247,27 @@ ${answer}
    */
   async publish(target, contents, overwrite, conceptId2) {
     const staging = `${target}.${process.pid}.tmp`;
-    await (0, import_promises10.writeFile)(staging, contents, "utf8");
+    await (0, import_promises12.writeFile)(staging, contents, "utf8");
     try {
       if (overwrite) {
-        await (0, import_promises10.rename)(staging, target);
+        await (0, import_promises12.rename)(staging, target);
         return;
       }
-      await (0, import_promises10.link)(staging, target);
+      await (0, import_promises12.link)(staging, target);
     } catch (error) {
       if (error.code === "EEXIST") {
         throw new KbRecordAlreadyExistsError(conceptId2);
       }
       throw error;
     } finally {
-      await (0, import_promises10.unlink)(staging).catch(() => void 0);
+      await (0, import_promises12.unlink)(staging).catch(() => void 0);
     }
   }
   /**
    * Declares union merge for the log, so two worktrees writing the same
    * bundle interleave their `log.jsonl` lines on merge rather than one
-   * side's appends silently losing to git's ordinary line-level merge.
+   * side's appends silently losing to git's ordinary line-level merge — and
+   * marks every store-owned file generated, so GitHub collapses it in a diff.
    *
    * Called from `record` — every path that appends a log line, not just
    * `write` — so a bundle only ever mutated through `setStatus`/`verify`/
@@ -6491,10 +8280,9 @@ ${answer}
    * race and created the file between the `readFile` below and this call,
    * `wx` fails instead of truncating what that writer just wrote, and the
    * failure is swallowed by the catch below same as any other best-effort
-   * miss. A file that exists but declares no merge strategy for the log
-   * gets the line appended, never a wholesale rewrite; one that already
-   * declares any merge strategy — this one or a user's own — is left alone
-   * entirely (see `hasMergeDeclaration`).
+   * miss. A file that exists gets only the lines it lacks appended, never a
+   * wholesale rewrite; an attribute it already sets — this one's value or a
+   * user's own — is left alone (see `missingGitattributesLines`).
    *
    * `readFile` failing is `existing === null` only for `ENOENT` — genuinely
    * missing. Any other error (a permission problem, a transient `EMFILE`,
@@ -6505,29 +8293,29 @@ ${answer}
    * therefore left untouched and reported as a failure like any other.
    *
    * Two processes racing the append branch — both read a file without the
-   * line, both append it — is possible and left unguarded: `appendFile` is
-   * `O_APPEND`, so the result is two copies of the same line rather than a
-   * torn write, and `hasMergeDeclaration` sees a duplicate declaration as
-   * "already declared" on the next call. A cheap-to-detect, harmless-to-
-   * leave residue, not a reason to add a cross-process lock (see
-   * `ARCHITECTURE.md`'s rejection of one for the same trade on records).
+   * lines, both append them — is possible and left unguarded: `appendFile` is
+   * `O_APPEND`, so the result is two copies of the same lines rather than a
+   * torn write, and the next call sees a duplicate declaration as "already
+   * declared". A cheap-to-detect, harmless-to-leave residue, not a reason to
+   * add a cross-process lock (see `ARCHITECTURE.md`'s rejection of one for
+   * the same trade on records).
    *
    * Best-effort, like the log append it precedes: failing to write this
    * file must not fail the mutation it guards.
    */
   async ensureGitattributes(root) {
-    const target = (0, import_node_path11.join)(root, GITATTRIBUTES_FILE);
+    const target = (0, import_node_path14.join)(root, GITATTRIBUTES_FILE);
     try {
       let existing;
       try {
-        existing = await (0, import_promises10.readFile)(target, "utf8");
+        existing = await (0, import_promises12.readFile)(target, "utf8");
       } catch (error) {
         if (error.code !== "ENOENT") throw error;
         existing = null;
       }
       if (existing === null) {
         try {
-          await (0, import_promises10.writeFile)(target, appendUnionMergeLine(""), {
+          await (0, import_promises12.writeFile)(target, appendGitattributesLines(""), {
             encoding: "utf8",
             flag: "wx"
           });
@@ -6547,8 +8335,9 @@ ${answer}
         });
         return;
       }
-      if (!hasMergeDeclaration(existing)) {
-        await (0, import_promises10.appendFile)(target, appendUnionMergeLine(existing), "utf8");
+      const addition = appendGitattributesLines(existing);
+      if (addition) {
+        await (0, import_promises12.appendFile)(target, addition, "utf8");
         this.logger.info?.({
           operation: "kb.gitattributes.ensure",
           bundlePath: root,
@@ -6567,7 +8356,7 @@ ${answer}
   async record(root, entry) {
     await this.ensureGitattributes(root);
     const line = renderLogEntry({ at: (/* @__PURE__ */ new Date()).toISOString(), ...entry });
-    await (0, import_promises10.appendFile)((0, import_node_path11.join)(root, LOG_FILE), line, "utf8").catch((error) => {
+    await (0, import_promises12.appendFile)((0, import_node_path14.join)(root, LOG_FILE), line, "utf8").catch((error) => {
       this.logger.warn?.({
         operation: "kb.log.append",
         outcome: "failed",
@@ -6593,18 +8382,18 @@ ${answer}
     };
   }
   root(bundlePath2) {
-    return (0, import_node_path11.resolve)(bundlePath2);
+    return (0, import_node_path14.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_path11.sep) || conceptId2.includes("/")) {
+    if (conceptId2.includes(import_node_path14.sep) || conceptId2.includes("/")) {
       throw new KbInvalidConceptIdError(
         "concept id must not contain a path separator",
         { conceptId: conceptId2 }
       );
     }
-    return (0, import_node_path11.join)(this.root(bundlePath2), `${conceptId2}.md`);
+    return (0, import_node_path14.join)(this.root(bundlePath2), `${conceptId2}.md`);
   }
 };
 function estimateTokens(record) {
@@ -6644,7 +8433,7 @@ function normalizeActor(id) {
 }
 
 // src/version.ts
-var VERSION = true ? "0.1.19" : "0.0.0-dev";
+var VERSION = true ? "0.1.20" : "0.0.0-dev";
 
 // src/mcp.ts
 function createKbMcpServer() {